/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "ui节点创建菜单.h"

#include "节点类型构建/构建时间轴编辑节点.h"
#include "节点类型构建/构建视频图像节点.h"
#include "节点类型构建/构建渲染器节点.h"
#include "节点类型构建/构建几何节点.h"
#include "节点类型构建/构建物理节点.h"
#include "节点类型构建/构建逻辑节点.h"
#include "节点类型构建/构建数据节点.h"
#include "节点类型构建/构建调试节点.h"
#include "节点类型构建/物体节点构建.h"
#include "节点类型构建/构建容器节点.h"
#include "节点类型构建/构建场景节点.h"
#include "节点类型构建/构建计算节点.h"
#include "节点类型构建/构建脚本节点.h"


#include "节点构建.h"
#include "节点操作.h"

#include "A_引擎/引擎.h"

#include <节点/逻辑/单节点脚本.h>
#include <节点/socket_utils.h> 
 
      
	  
 
static S_UI渲染环境* g当前UI环境 = 0;

static fp_节点创建视口回调 fun_节点视口回调 = 0;
static fp_节点添加到视口回调 fun_创建多节点添加到视口回调 = 0;




bool f_on_网格2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;

	if (name == u"网格") {
		node = f_节点构建_几何网格(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"网格编辑") {
		node = f_节点构建_编辑网格(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"从网格构建体素") {
		node = f_节点构建_网格体素(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"网格采样") {
		node = f_节点构建_网格采样(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"计算法线") {
		node = f_节点构建_计算网格法线(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"截取网格") {
		node = f_节点构建_截取网格(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"网格属性") {
		node = f_节点构建_网格属性(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"填充顶点") {
		node = f_节点构建_填充网格顶点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"填充纹理坐标") {
		node = f_节点构建_填充网格纹理坐标(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"多边形桥接") {
		node = f_节点构建_多边形桥接节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"点桥接") {
		node = f_节点构建_点桥接节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"边实体化") {
		node = f_节点构建_多边形边实体化节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"边网格化") {
		node = f_节点构建_边网格化节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"边采样") {
		node = f_节点构建_多边形边采样节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"顶点数据") {
		node = f_节点构建_几何数据(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"面朝向") {
		node = f_节点构建_面朝向(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"UV") {
		node = f_节点构建_几何UV数据(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"光线数据") {
		node = f_节点构建_光线数据(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"投影坐标") {
		node = f_节点构建_投影多边形纹理坐标(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"复制多边形") {
		node = f_节点构建_多边形复制节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"拷贝多边形") {
		node = f_节点构建_多边形拷贝节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"变换多边形") {
		node = f_节点构建_多边形变换节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取多边形面顶点") {
		node = f_节点构建_取多边形面顶点节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"设置多边形面顶点") {
		node = f_节点构建_设置多边形面顶点节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"多边形转网格") {
		node = f_节点构建_多边形转网格节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取多边形边") {
		node = f_节点构建_取多边形边节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else {
		if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
			node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
		}
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}



static S_菜单创建参数 g可编译_材质几何数据 = {
	f_on_网格2级节点创建菜单项, {

		{u"顶点数据", u"", u"", 0},
		{u"UV", u"", u"", 0},
		{u"光线数据", u"", u"", 0},
		{u"投影坐标", u"", u"", 0},
		//{u"计算法线", "", 0},
		//{u"截取网格", "", 0},
		//{u"网格属性", "", 0},
		}
};

static S_菜单创建参数 g可编译_几何着色元素菜单项 = {
	f_on_网格2级节点创建菜单项, {
		{u"面轮廓", u"", u"", 0},
		{u"线", u"", u"", 0},
		//{u"光线数据", "", 0},
		//{u"投影坐标", "", 0},
	}
};



void f_init_物体节点创建_绑定视口回调(fp_节点创建视口回调 fun, fp_节点添加到视口回调 多节点创建回调) {
	fun_节点视口回调 = fun;
	fun_创建多节点添加到视口回调 = 多节点创建回调;

	C_节点面板::g节点构建函数_创建名称对应类型名称[u"网格选择"] = DEF_网格选择节点;
	C_节点面板::g节点构建函数_创建名称对应类型名称[u"面朝向"] = DEF_面朝向节点;

	C_节点面板::g节点面板构建函数["射线拾取节点"] = f_节点构建_射线物体拾取;
	C_节点面板::g节点面板构建函数["范围拾取节点"] = f_节点构建_范围拾取;
	C_节点面板::g节点面板构建函数["帧时间节点"] = f_节点构建_帧时间;
	C_节点面板::g节点面板重置函数["帧时间节点"] = f_节点重置_帧时间;
	C_节点面板::g节点面板构建函数["OpenVDB网格节点"] = f_节点构建_OpenVDB网格;
	C_节点面板::g节点面板重置函数["OpenVDB网格节点"] = f_节点重置_OpenVDB网格;

	//================================ 网格 =========================================
	C_节点面板::g节点面板构建函数["平面网格节点"] = f_节点构建_几何平面;
	C_节点面板::g节点面板重置函数["平面网格节点"] = f_节点重置_几何平面;
	C_节点面板::g节点面板构建函数["球体网格生成节点"] = f_节点构建_几何球体;
	C_节点面板::g节点面板重置函数["球体网格生成节点"] = f_节点重置_几何球体;
	C_节点面板::g节点面板构建函数["矩形网格生成节点"] = f_节点构建_几何矩形;
	C_节点面板::g节点面板重置函数["矩形网格生成节点"] = f_节点重置_几何矩形;
	C_节点面板::g节点面板构建函数["线框立方体节点"] = f_节点构建_线框立方体;
	C_节点面板::g节点面板重置函数["线框立方体节点"] = f_节点重置_线框立方体;

	C_节点面板::g节点面板构建函数["网格体素节点"] = f_节点构建_网格体素;
	C_节点面板::g节点面板构建函数["网格采样节点"] = f_节点构建_网格采样;
	C_节点面板::g节点面板构建函数["网格属性节点"] = f_节点构建_网格属性;
	C_节点面板::g节点面板重置函数["网格属性节点"] = f_节点重置_网格属性;
	C_节点面板::g节点面板构建函数[DEF_网格选择节点] = f_节点构建_网格选择;
	C_节点面板::g节点面板重置函数[DEF_网格选择节点] = f_节点重置_网格选择;

	C_节点面板::g节点面板构建函数[DEF_面朝向节点] = f_节点构建_面朝向;
	C_节点面板::g节点面板重置函数[DEF_面朝向节点] = f_节点重置_面朝向;

	C_节点面板::g节点面板构建函数[DEF_网格节点] = f_节点构建_几何网格;
	C_节点面板::g节点面板重置函数[DEF_网格节点] = f_节点重置_几何网格;

	C_节点面板::g节点面板构建函数[DEF_几何节点] = f_节点构建_几何;
	C_节点面板::g节点面板重置函数[DEF_几何节点] = f_节点重置_几何;

	C_节点面板::g节点面板构建函数[DEF_几何ID节点] = f_节点构建_几何ID;
	C_节点面板::g节点面板重置函数[DEF_几何ID节点] = f_节点重置_几何ID;

	C_节点面板::g节点面板构建函数[DEF_当前多边形节点] = f_节点构建_当前多边形;
	C_节点面板::g节点面板重置函数[DEF_当前多边形节点] = f_节点重置_当前多边形;

	C_节点面板::g节点面板构建函数[DEF_基本多边形节点] = f_节点构建_基本多边形;
	C_节点面板::g节点面板重置函数[DEF_基本多边形节点] = f_节点重置_基本多边形;
	C_节点面板::g节点面板构建函数[DEF_多边形边节点] = f_节点构建_多边形边;
	C_节点面板::g节点面板重置函数[DEF_多边形边节点] = f_节点重置_多边形边;
	C_节点面板::g节点面板构建函数[DEF_添加纹理坐标节点] = f_节点构建_添加多边形纹理坐标;
	C_节点面板::g节点面板重置函数[DEF_添加纹理坐标节点] = f_节点重置_添加多边形纹理坐标;

	C_节点面板::g节点面板构建函数[DEF_添加多边形元素节点] = f_节点构建_添加多边形元素;
	C_节点面板::g节点面板重置函数[DEF_添加多边形元素节点] = f_节点重置_添加多边形元素;

	C_节点面板::g节点面板构建函数[DEF_多边形面节点] = f_节点构建_多边形面;
	C_节点面板::g节点面板重置函数[DEF_多边形面节点] = f_节点重置_多边形面;
	C_节点面板::g节点面板构建函数[DEF_多边形节点] = f_节点构建_多边形;
	C_节点面板::g节点面板重置函数[DEF_多边形节点] = f_节点重置_多边形;
	C_节点面板::g节点面板构建函数[DEF_多边形添加顶点节点] = f_节点构建_多边形添加顶点;
	C_节点面板::g节点面板重置函数[DEF_多边形添加顶点节点] = f_节点重置_多边形添加顶点;
	C_节点面板::g节点面板构建函数[DEF_多边形删除顶点节点] = f_节点构建_多边形删除顶点;
	C_节点面板::g节点面板重置函数[DEF_多边形删除顶点节点] = f_节点重置_多边形删除顶点;
	C_节点面板::g节点面板构建函数[DEF_多边形桥接节点] = f_节点构建_多边形桥接节点;
	C_节点面板::g节点面板重置函数[DEF_多边形桥接节点] = f_节点重置_多边形桥接节点;
	C_节点面板::g节点面板构建函数[DEF_点桥接节点] = f_节点构建_点桥接节点;
	C_节点面板::g节点面板重置函数[DEF_点桥接节点] = f_节点重置_点桥接节点;

	C_节点面板::g节点面板构建函数[DEF_多边形边实体化节点] = f_节点构建_多边形边实体化节点;
	C_节点面板::g节点面板重置函数[DEF_多边形边实体化节点] = f_节点重置_多边形边实体化节点;

	C_节点面板::g节点面板构建函数[DEF_多边形边采样节点] = f_节点构建_多边形边采样节点;
	C_节点面板::g节点面板重置函数[DEF_多边形边采样节点] = f_节点重置_多边形边采样节点;

	C_节点面板::g节点面板构建函数[DEF_多边形索引节点] = f_节点构建_取多边形索引节点;
	C_节点面板::g节点面板重置函数[DEF_多边形索引节点] = f_节点重置_取多边形索引节点;

	C_节点面板::g节点面板构建函数[DEF_多边形复制节点] = f_节点构建_多边形复制节点;
	C_节点面板::g节点面板重置函数[DEF_多边形复制节点] = f_节点重置_多边形复制节点;

	C_节点面板::g节点面板构建函数[DEF_多边形拷贝节点] = f_节点构建_多边形拷贝节点;
	C_节点面板::g节点面板重置函数[DEF_多边形拷贝节点] = f_节点重置_多边形拷贝节点;

	C_节点面板::g节点面板构建函数[DEF_多边形变换节点] = f_节点构建_多边形变换节点;
	C_节点面板::g节点面板重置函数[DEF_多边形变换节点] = f_节点重置_多边形变换节点;

	C_节点面板::g节点面板构建函数[DEF_取多边形面属性节点] = f_节点构建_取多边形面属性节点;
	C_节点面板::g节点面板重置函数[DEF_取多边形面属性节点] = f_节点重置_取多边形面属性节点;

	C_节点面板::g节点面板构建函数[DEF_取多边形面元素节点] = f_节点构建_取多边形元素;
	C_节点面板::g节点面板重置函数[DEF_取多边形面元素节点] = f_节点重置_取多边形元素;

	C_节点面板::g节点面板构建函数[DEF_设置多边形面属性节点] = f_节点构建_设置多边形面属性节点;
	C_节点面板::g节点面板重置函数[DEF_设置多边形面属性节点] = f_节点重置_设置多边形面属性节点;

	C_节点面板::g节点面板构建函数[DEF_设置多边形面UV节点] = f_节点构建_设置多边形面UV节点;
	C_节点面板::g节点面板重置函数[DEF_设置多边形面UV节点] = f_节点重置_设置多边形面UV节点;

	C_节点面板::g节点面板构建函数[DEF_取多边形面顶点节点] = f_节点构建_取多边形面顶点节点;
	C_节点面板::g节点面板重置函数[DEF_取多边形面顶点节点] = f_节点重置_取多边形面顶点节点;

	C_节点面板::g节点面板构建函数[DEF_设置多边形面顶点节点] = f_节点构建_设置多边形面顶点节点;
	C_节点面板::g节点面板重置函数[DEF_设置多边形面顶点节点] = f_节点重置_设置多边形面顶点节点;

	C_节点面板::g节点面板构建函数[DEF_设置面材质槽ID节点] = f_节点构建_设置面材质槽ID节点;
	C_节点面板::g节点面板重置函数[DEF_设置面材质槽ID节点] = f_节点重置_设置面材质槽ID节点;

	C_节点面板::g节点面板构建函数[DEF_填充网格顶点节点] = f_节点构建_填充网格顶点;
	C_节点面板::g节点面板重置函数[DEF_填充网格顶点节点] = f_节点重置_填充网格顶点;
	C_节点面板::g节点面板构建函数[DEF_填充网格纹理坐标节点] = f_节点构建_填充网格纹理坐标;
	C_节点面板::g节点面板重置函数[DEF_填充网格纹理坐标节点] = f_节点重置_填充网格纹理坐标;
	C_节点面板::g节点面板构建函数[DEF_投影纹理坐标节点] = f_节点构建_投影多边形纹理坐标;
	C_节点面板::g节点面板重置函数[DEF_投影纹理坐标节点] = f_节点重置_投影多边形纹理坐标;

	C_节点面板::g节点面板构建函数[DEF_多边形转网格节点] = f_节点构建_多边形转网格节点;
	C_节点面板::g节点面板重置函数[DEF_多边形转网格节点] = f_节点重置_多边形转网格节点;

	C_节点面板::g节点面板构建函数[DEF_取多边形边节点] = f_节点构建_取多边形边节点;
	C_节点面板::g节点面板重置函数[DEF_取多边形边节点] = f_节点重置_取多边形边节点;

	C_节点面板::g节点面板构建函数[DEF_创建网格自定义属性节点] = f_节点构建_创建网格自定义属性节点;
	C_节点面板::g节点面板重置函数[DEF_创建网格自定义属性节点] = f_节点重置_创建网格自定义属性节点;

	C_节点面板::g节点面板构建函数[DEF_设置网格面自定义属性节点] = f_节点构建_设置网格自定义属性节点;
	C_节点面板::g节点面板重置函数[DEF_设置网格面自定义属性节点] = f_节点重置_设置网格自定义属性节点;



	//================================ 计算 =========================================
	C_节点面板::g节点面板构建函数[DEF_回写节点] = f_节点构建_回写节点;
	C_节点面板::g节点面板重置函数[DEF_回写节点] = f_节点重置_回写节点;

	C_节点面板::g节点面板构建函数["单值计算节点"] = f_节点构建_单值计算;
	C_节点面板::g节点面板重置函数["单值计算节点"] = f_节点重置_单值计算;

	C_节点面板::g节点面板构建函数[DEF_位运算节点] = f_节点构建_位运算;
	C_节点面板::g节点面板重置函数[DEF_位运算节点] = f_节点重置_位运算;

	C_节点面板::g节点面板构建函数[DEF_单目计算节点] = f_节点构建_单目计算;
	C_节点面板::g节点面板重置函数[DEF_单目计算节点] = f_节点重置_单目计算;

	C_节点面板::g节点面板构建函数[DEF_累计计算节点] = f_节点构建_累计计算;
	C_节点面板::g节点面板重置函数[DEF_累计计算节点] = f_节点重置_累计计算;

	C_节点面板::g节点面板构建函数[DEF_矢量计算节点] = f_节点构建_矢量计算;
	C_节点面板::g节点面板重置函数[DEF_矢量计算节点] = f_节点重置_矢量计算;
	
	C_节点面板::g节点面板构建函数[DEF_合并XYZ节点] = f_节点构建_合并XYZ;
	C_节点面板::g节点面板重置函数[DEF_合并XYZ节点] = f_节点重置_合并XYZ;

	C_节点面板::g节点面板构建函数[DEF_分离XYZ节点] = f_节点构建_分离XYZ;
	C_节点面板::g节点面板重置函数[DEF_分离XYZ节点] = f_节点重置_分离XYZ;

	C_节点面板::g节点面板构建函数[DEF_混合计算节点] = f_节点构建_混合;
	C_节点面板::g节点面板重置函数[DEF_混合计算节点] = f_节点重置_混合;

	C_节点面板::g节点面板构建函数["矩阵变换节点"] = f_节点构建_矩阵变换;
	C_节点面板::g节点面板重置函数["矩阵变换节点"] = f_节点重置_矩阵变换;

	C_节点面板::g节点面板构建函数[DEF_两向量转四元数] = f_节点构建_向量转四元数;
	C_节点面板::g节点面板重置函数[DEF_两向量转四元数] = f_节点重置_向量转四元数;
	
	C_节点面板::g节点面板构建函数[DEF_向量角度组成四元数节点] = f_节点构建_向量角度组成四元数;
	C_节点面板::g节点面板重置函数[DEF_向量角度组成四元数节点] = f_节点重置_向量角度组成四元数;
	C_节点面板::g节点面板构建函数[DEF_四元数转换为欧拉角节点] = f_节点构建_四元数转换为欧拉角;
	C_节点面板::g节点面板重置函数[DEF_四元数转换为欧拉角节点] = f_节点重置_四元数转换为欧拉角;
	C_节点面板::g节点面板构建函数[DEF_四元数转换为4X4矩阵节点] = f_节点构建_四元数转换为矩阵节点;
	C_节点面板::g节点面板重置函数[DEF_四元数转换为4X4矩阵节点] = f_节点重置_四元数转换为矩阵节点;
	C_节点面板::g节点面板构建函数[DEF_顶点变换节点] = f_节点构建_顶点变换;
	C_节点面板::g节点面板重置函数[DEF_顶点变换节点] = f_节点重置_顶点变换;

	C_节点面板::g节点面板构建函数[DEF_平面到点节点] = f_节点构建_平面到点节点;
	C_节点面板::g节点面板重置函数[DEF_平面到点节点] = f_节点重置_平面到点节点;

	C_节点面板::g节点面板构建函数[DEF_平面线段相交节点] = f_节点构建_平面线段相交节点;
	C_节点面板::g节点面板重置函数[DEF_平面线段相交节点] = f_节点重置_平面线段相交节点;

	C_节点面板::g节点面板构建函数[DEF_坐标转索引节点] = f_节点构建_坐标转索引节点;
	C_节点面板::g节点面板重置函数[DEF_坐标转索引节点] = f_节点重置_坐标转索引节点;

	C_节点面板::g节点面板构建函数[DEF_索引转坐标节点] = f_节点构建_索引转坐标节点;
	C_节点面板::g节点面板重置函数[DEF_索引转坐标节点] = f_节点重置_索引转坐标节点;

	C_节点面板::g节点面板构建函数["矩阵计算节点"] = f_节点构建_矩阵计算;
	C_节点面板::g节点面板重置函数["矩阵计算节点"] = f_节点重置_矩阵计算;
	C_节点面板::g节点面板构建函数[DEF_矩阵转换节点] = f_节点构建_矩阵转换;
	C_节点面板::g节点面板重置函数[DEF_矩阵转换节点] = f_节点重置_矩阵转换;

	C_节点面板::g节点面板构建函数[DEF_圆坐标生成节点] = f_节点构建_圆坐标生成节点;
	C_节点面板::g节点面板重置函数[DEF_圆坐标生成节点] = f_节点重置_圆坐标生成节点;
	C_节点面板::g节点面板构建函数[DEF_直线坐标生成节点] = f_节点构建_直线;
	C_节点面板::g节点面板重置函数[DEF_直线坐标生成节点] = f_节点重置_直线;
	C_节点面板::g节点面板构建函数[DEF_渐变采样节点] = f_节点构建_渐变采样;
	C_节点面板::g节点面板重置函数[DEF_渐变采样节点] = f_节点重置_渐变采样;
	C_节点面板::g节点面板构建函数[DEF_单值钳制节点] = f_节点构建_单值钳制;
	C_节点面板::g节点面板重置函数[DEF_单值钳制节点] = f_节点重置_单值钳制;

	C_节点面板::g节点面板构建函数[DEF_矢量钳制节点] = f_节点构建_矢量钳制;
	C_节点面板::g节点面板重置函数[DEF_矢量钳制节点] = f_节点重置_矢量钳制;

	C_节点面板::g节点面板构建函数[DEF_三角函数节点] = f_节点构建_三角函数计算;
	C_节点面板::g节点面板重置函数[DEF_三角函数节点] = f_节点重置_三角函数计算;
	C_节点面板::g节点面板构建函数[DEF_归一化节点] = f_节点构建_归一化计算;
	C_节点面板::g节点面板重置函数[DEF_归一化节点] = f_节点重置_归一化计算;
	C_节点面板::g节点面板构建函数[DEF_向量标量计算节点] = f_节点构建_向量长度;
	C_节点面板::g节点面板重置函数[DEF_向量标量计算节点] = f_节点重置_向量长度;
	C_节点面板::g节点面板构建函数[DEF_两向量标量计算节点] = f_节点构建_两向量标量计算;
	C_节点面板::g节点面板重置函数[DEF_两向量标量计算节点] = f_节点重置_两向量标量计算;
	C_节点面板::g节点面板构建函数[DEF_旋转向量节点] = f_节点构建_旋转向量节点;
	C_节点面板::g节点面板重置函数[DEF_旋转向量节点] = f_节点重置_旋转向量节点;
	C_节点面板::g节点面板构建函数[DEF_按轴向旋转向量节点] = f_节点构建_轴向旋转向量节点;
	C_节点面板::g节点面板重置函数[DEF_按轴向旋转向量节点] = f_节点重置_轴向旋转向量节点;
	C_节点面板::g节点面板构建函数[DEF_绕点旋转节点] = f_节点构建_绕点旋转;
	C_节点面板::g节点面板重置函数[DEF_绕点旋转节点] = f_节点重置_绕点旋转;

	C_节点面板::g节点面板构建函数[DEF_步进计算节点] = f_节点构建_步进计算节点;
	C_节点面板::g节点面板重置函数[DEF_步进计算节点] = f_节点重置_步进计算节点;

	C_节点面板::g节点面板构建函数[DEF_索引数组排序节点] = f_节点构建_索引数组排序;
	C_节点面板::g节点面板重置函数[DEF_索引数组排序节点] = f_节点重置_索引数组排序;

	C_节点面板::g节点面板构建函数[DEF_取空间邻接数据节点] = f_节点构建_取空间邻接数据;
	C_节点面板::g节点面板重置函数[DEF_取空间邻接数据节点] = f_节点重置_取空间邻接数据;

	C_节点面板::g节点面板构建函数[DEF_几何计算节点] = f_节点构建_几何计算;
	C_节点面板::g节点面板重置函数[DEF_几何计算节点] = f_节点重置_几何计算;

	
	//============================================ 变量 ============================================================
	C_节点面板::g节点面板构建函数[DEF_变量引用节点] = f_节点构建_变量引用;
	C_节点面板::g节点面板重置函数[DEF_变量引用节点] = f_节点重置_变量引用;

	C_节点面板::g节点面板构建函数[DEF_I8变量节点] = f_节点构建_I8变量;
	C_节点面板::g节点面板重置函数[DEF_I8变量节点] = f_节点重置_I8变量;

	C_节点面板::g节点面板构建函数["浮点变量节点"] = f_节点构建_单值浮点变量;
	C_节点面板::g节点面板重置函数["浮点变量节点"] = f_节点重置_单值浮点变量;
	C_节点面板::g节点面板重置函数["整数变量节点"] = f_节点重置_单值整数变量;
	C_节点面板::g节点面板构建函数["整数变量节点"] = f_节点构建_单值整数变量;

	C_节点面板::g节点面板构建函数[DEF_无符号整数变量节点] = f_节点构建_无符号整数变量;
	C_节点面板::g节点面板重置函数[DEF_无符号整数变量节点] = f_节点重置_无符号整数变量;

	C_节点面板::g节点面板构建函数["vec3变量节点"] = f_节点构建_vec3变量;
	C_节点面板::g节点面板重置函数["vec3变量节点"] = f_节点重置_vec3变量;
	C_节点面板::g节点面板构建函数[DEF_vec2变量节点] = f_节点构建_vec2变量;
	C_节点面板::g节点面板重置函数[DEF_vec2变量节点] = f_节点重置_vec2变量;

	C_节点面板::g节点面板构建函数[DEF_I8数组变量节点] = f_节点构建_I8数组变量;
	C_节点面板::g节点面板重置函数[DEF_I8数组变量节点] = f_节点重置_I8数组变量;

	C_节点面板::g节点面板构建函数[DEF_F32数组变量节点] = f_节点构建_F32数组变量;
	C_节点面板::g节点面板重置函数[DEF_F32数组变量节点] = f_节点重置_F32数组变量;
	C_节点面板::g节点面板构建函数[DEF_I32数组变量节点] = f_节点构建_I32数组变量构建;
	C_节点面板::g节点面板重置函数[DEF_I32数组变量节点] = f_节点重置_I32数组变量构建;

	C_节点面板::g节点面板构建函数[DEF_UI32数组变量节点] = f_节点构建_UI32数组变量构建;
	C_节点面板::g节点面板重置函数[DEF_UI32数组变量节点] = f_节点重置_UI32数组变量构建;

	C_节点面板::g节点面板构建函数["vec2数组变量节点"] = f_节点构建_vec2数组变量;
	C_节点面板::g节点面板重置函数["vec2数组变量节点"] = f_节点重置_vec2数组变量;
	C_节点面板::g节点面板构建函数["vec3数组变量节点"] = f_节点构建_vec3数组变量;
	C_节点面板::g节点面板重置函数["vec3数组变量节点"] = f_节点重置_vec3数组变量;

	C_节点面板::g节点面板构建函数[DEF_ivec3变量节点] = f_节点构建_ivec3变量;
	C_节点面板::g节点面板重置函数[DEF_ivec3变量节点] = f_节点重置_ivec3变量;

	C_节点面板::g节点面板构建函数[DEF_Vec4数组变量节点] = f_节点构建_vec4数组变量;
	C_节点面板::g节点面板重置函数[DEF_Vec4数组变量节点] = f_节点重置_vec4数组变量;

	C_节点面板::g节点面板构建函数[DEF_ivec2数组变量节点] = f_节点构建_ivec2数组变量;
	C_节点面板::g节点面板重置函数[DEF_ivec2数组变量节点] = f_节点重置_ivec2数组变量;

	C_节点面板::g节点面板构建函数[DEF_ivec3数组变量节点] = f_节点构建_ivec3数组变量;
	C_节点面板::g节点面板重置函数[DEF_ivec3数组变量节点] = f_节点重置_ivec3数组变量;

	C_节点面板::g节点面板构建函数["vec球数组节点"] = f_节点构建_VecSphere数组变量;

	C_节点面板::g节点面板构建函数[DEF_合并数据节点] = f_节点构建_合并数据;
	C_节点面板::g节点面板重置函数[DEF_合并数据节点] = f_节点重置_合并数据;

	C_节点面板::g节点面板构建函数["矩阵构建节点"] = f_节点构建_矩阵构建;
	C_节点面板::g节点面板重置函数["矩阵构建节点"] = f_节点重置_矩阵构建;

	C_节点面板::g节点面板构建函数[DEF_坐标构建平面变量节点] = f_节点构建_平面变量;
	C_节点面板::g节点面板重置函数[DEF_坐标构建平面变量节点] = f_节点重置_平面变量;

	C_节点面板::g节点面板构建函数[DEF_观察矩阵构建节点] = f_节点构建_观察矩阵构建;
	C_节点面板::g节点面板重置函数[DEF_观察矩阵构建节点] = f_节点重置_观察矩阵构建;

	C_节点面板::g节点面板构建函数[DEF_多边形成员数组变量节点] = f_节点构建_多边形成员数组变量;
	C_节点面板::g节点面板重置函数[DEF_多边形成员数组变量节点] = f_节点重置_多边形成员数组变量;
	
	C_节点面板::g节点面板构建函数[DEF_数组变量节点] = f_节点构建_数组变量;
	C_节点面板::g节点面板重置函数[DEF_数组变量节点] = f_节点重置_数组变量;

	C_节点面板::g节点面板构建函数[DEF_添加数组元素节点] = f_节点构建_数组添加元素;
	C_节点面板::g节点面板重置函数[DEF_添加数组元素节点] = f_节点重置_数组添加元素;

	C_节点面板::g节点面板构建函数[DEF_取数组属性节点] = f_节点构建_数组属性;
	C_节点面板::g节点面板重置函数[DEF_取数组属性节点] = f_节点重置_数组属性;

	C_节点面板::g节点面板构建函数[DEF_取数组元素节点] = f_节点构建_取数组元素;
	C_节点面板::g节点面板重置函数[DEF_取数组元素节点] = f_节点重置_取数组元素;

	C_节点面板::g节点面板构建函数[DEF_取数组头尾元素节点] = f_节点构建_取数组头尾元素;
	C_节点面板::g节点面板重置函数[DEF_取数组头尾元素节点] = f_节点重置_取数组头尾元素;

	C_节点面板::g节点面板构建函数[DEF_取内存邻接数据节点] = f_节点构建_取内存邻接数据;
	C_节点面板::g节点面板重置函数[DEF_取内存邻接数据节点] = f_节点重置_取内存邻接数据;
	
	C_节点面板::g节点面板构建函数[DEF_合并数组元素节点] = f_节点构建_合并数组;
	C_节点面板::g节点面板重置函数[DEF_合并数组元素节点] = f_节点重置_合并数组;
	C_节点面板::g节点面板构建函数[DEF_插入数组节点] = f_节点构建_插入数组节点;
	C_节点面板::g节点面板重置函数[DEF_插入数组节点] = f_节点重置_插入数组节点;

	C_节点面板::g节点面板构建函数[DEF_删除数组元素节点] = f_节点构建_删除数组元素;
	C_节点面板::g节点面板重置函数[DEF_删除数组元素节点] = f_节点重置_删除数组元素;

	C_节点面板::g节点面板构建函数[DEF_查找数组元素节点] = f_节点构建_查找数组元素;
	C_节点面板::g节点面板重置函数[DEF_查找数组元素节点] = f_节点重置_查找数组元素;

	C_节点面板::g节点面板构建函数[DEF_数组元素统计节点] = f_节点构建_数组元素统计;
	C_节点面板::g节点面板重置函数[DEF_数组元素统计节点] = f_节点重置_数组元素统计;

	C_节点面板::g节点面板构建函数[DEF_复制数组节点] = f_节点构建_复制数据;
	C_节点面板::g节点面板重置函数[DEF_复制数组节点] = f_节点重置_复制数据;

	C_节点面板::g节点面板构建函数[DEF_数组重排节点] = f_节点构建_数组重排;
	C_节点面板::g节点面板重置函数[DEF_数组重排节点] = f_节点重置_数组重排;

	C_节点面板::g节点面板构建函数[DEF_数组打乱节点] = f_节点构建_数组打乱;
	C_节点面板::g节点面板重置函数[DEF_数组打乱节点] = f_节点重置_数组打乱;

	C_节点面板::g节点面板构建函数[DEF_数组抽取节点] = f_节点构建_数组抽取;
	C_节点面板::g节点面板重置函数[DEF_数组抽取节点] = f_节点重置_数组抽取;

	C_节点面板::g节点面板构建函数[DEF_文件路径节点] = f_节点构建_文件路径节点;
	C_节点面板::g节点面板重置函数[DEF_文件路径节点] = f_节点重置_文件路径节点;

	C_节点面板::g节点面板构建函数[DEF_行字符串变量节点] = f_节点构建_行字符串;
	C_节点面板::g节点面板重置函数[DEF_行字符串变量节点] = f_节点重置_行字符串;

	C_节点面板::g节点面板构建函数[DEF_行字符串数组变量节点] = f_节点构建_行字符串数组;
	C_节点面板::g节点面板重置函数[DEF_行字符串数组变量节点] = f_节点重置_行字符串数组;

	C_节点面板::g节点面板构建函数[DEF_数值转字符串节点] = f_节点构建_数值转字符串;
	C_节点面板::g节点面板重置函数[DEF_数值转字符串节点] = f_节点重置_数值转字符串;

	C_节点面板::g节点面板构建函数[DEF_合并字符串节点] = f_节点构建_合并字符串;
	C_节点面板::g节点面板重置函数[DEF_合并字符串节点] = f_节点重置_合并字符串;

	C_节点面板::g节点面板构建函数["线段1D数据节点"] = f_节点构建_线段1D变量;

	C_节点面板::g节点面板构建函数["物理体节点"] = f_节点构建_物理体;
	C_节点面板::g节点面板构建函数["PBF解算器节点"] = f_节点构建_PBF解算器;
	
	C_节点面板::g节点面板构建函数["解算器更新节点"] = f_节点构建_解算器模拟;


	//================================= 物体 ======================================
	C_节点面板::g节点面板构建函数["物体节点"] = f_节点构建_物体节点;
	C_节点面板::g节点面板重置函数["物体节点"] = f_节点重置_物体节点;

	C_节点面板::g节点面板构建函数[DEF_引用物体节点] = f_节点构建_引用物体节点;
	C_节点面板::g节点面板重置函数[DEF_引用物体节点] = f_节点重置_引用物体节点;
	C_节点面板::g节点面板构建函数[DEF_取物体节点] = f_节点构建_取物体节点;
	C_节点面板::g节点面板重置函数[DEF_取物体节点] = f_节点重置_取物体节点;
	C_节点面板::g节点面板构建函数[DEF_取物体变换节点] = f_节点构建_取物体变换节点;
	C_节点面板::g节点面板重置函数[DEF_取物体变换节点] = f_节点重置_取物体变换节点;
	C_节点面板::g节点面板构建函数[DEF_取物体矩阵节点] = f_节点构建_取物体矩阵节点;
	C_节点面板::g节点面板重置函数[DEF_取物体矩阵节点] = f_节点重置_取物体矩阵节点;
	C_节点面板::g节点面板构建函数[DEF_查找子物体节点] = f_节点构建_查找子物体节点;
	C_节点面板::g节点面板重置函数[DEF_查找子物体节点] = f_节点重置_查找子物体节点;

	C_节点面板::g节点面板构建函数["物体父子关系节点"] = f_节点构建_物体父子关系节点;
	C_节点面板::g节点面板构建函数[DEF_取物体材质节点] = f_节点构建_取物体材质节点;
	C_节点面板::g节点面板构建函数["设置物体数据节点"] = f_节点构建_设置物体数据节点;
	C_节点面板::g节点面板构建函数["骨头节点"] = f_节点构建_骨头节点;
	C_节点面板::g节点面板构建函数["骨骼节点"] = f_节点构建_骨骼节点;
	C_节点面板::g节点面板构建函数["骨骼IK节点"] = f_节点构建_骨骼IK节点;
	C_节点面板::g节点面板构建函数["物体拷贝节点"] = f_节点构建_物体拷贝节点;
	C_节点面板::g节点面板构建函数["物体绑定骨骼节点"] = f_节点构建_物体拷贝节点;

	C_节点面板::g节点面板构建函数["设置物体矩阵节点"] = f_节点构建_设置物体矩阵节点;
	C_节点面板::g节点面板重置函数["设置物体矩阵节点"] = f_节点重置_设置物体矩阵节点;

	C_节点面板::g节点面板构建函数[DEF_设置摄像机属性节点] = f_节点构建_设置摄像机属性节点;
	C_节点面板::g节点面板重置函数[DEF_设置摄像机属性节点] = f_节点重置_设置摄像机属性节点;

	C_节点面板::g节点面板构建函数["设置物体变换节点"] = f_节点构建_设置物体变换节点;
	C_节点面板::g节点面板重置函数["设置物体变换节点"] = f_节点重置_设置物体变换节点;
	
	C_节点面板::g节点面板构建函数[DEF_外部加载物体节点] = f_节点构建_外部加载物体节点;
	C_节点面板::g节点面板重置函数[DEF_外部加载物体节点] = f_节点重置_外部加载物体节点;

	C_节点面板::g节点面板构建函数[DEF_摄像机节点] = f_节点构建_摄像机节点;
	C_节点面板::g节点面板重置函数[DEF_摄像机节点] = f_节点重置_摄像机节点;

	C_节点面板::g节点面板构建函数[DEF_目标摄像机节点] = f_节点构建_目标摄像机节点;
	C_节点面板::g节点面板重置函数[DEF_目标摄像机节点] = f_节点重置_目标摄像机节点;

	C_节点面板::g节点面板构建函数[DEF_点光源节点] = f_节点构建_点光源节点;
	C_节点面板::g节点面板重置函数[DEF_点光源节点] = f_节点重置_点光源节点;
	C_节点面板::g节点面板构建函数[DEF_区域光节点] = f_节点构建_面光源节点;
	C_节点面板::g节点面板重置函数[DEF_区域光节点] = f_节点重置_面光源节点;
	C_节点面板::g节点面板构建函数[DEF_聚光灯节点] = f_节点构建_聚光灯节点;
	C_节点面板::g节点面板重置函数[DEF_聚光灯节点] = f_节点重置_聚光灯节点;
	C_节点面板::g节点面板构建函数[DEF_平行光节点] = f_节点构建_平行光节点;
	C_节点面板::g节点面板重置函数[DEF_平行光节点] = f_节点重置_平行光节点;

	C_节点面板::g节点面板构建函数[DEF_选择物体节点] = f_节点构建_选择物体节点;
	C_节点面板::g节点面板重置函数[DEF_选择物体节点] = f_节点重置_选择物体节点;

	C_节点面板::g节点面板构建函数[DEF_加载模型节点] = f_节点构建_加载模型节点;
	C_节点面板::g节点面板重置函数[DEF_加载模型节点] = f_节点重置_加载模型节点;



	//================================= 材质着色 ======================================
	C_节点面板::g节点面板构建函数[DEF_材质槽节点] = f_节点构建_材质槽;
	C_节点面板::g节点面板重置函数[DEF_材质槽节点] = f_节点重置_材质槽;
	C_节点面板::g节点面板构建函数[DEF_材质编辑节点] = f_节点构建_材质;
	C_节点面板::g节点面板重置函数[DEF_材质编辑节点] = f_节点重置_材质;

	C_节点面板::g节点面板构建函数[DEF_当前材质节点] = f_节点构建_当前材质;
	C_节点面板::g节点面板重置函数[DEF_当前材质节点] = f_节点重置_当前材质;

	C_节点面板::g节点面板构建函数[DEF_二维纹理节点] = f_节点构建_纹理;
	C_节点面板::g节点面板重置函数[DEF_二维纹理节点] = f_节点重置_纹理;

	C_节点面板::g节点面板构建函数[DEF_外部纹理节点] = f_节点构建_外部纹理;
	C_节点面板::g节点面板重置函数[DEF_外部纹理节点] = f_节点重置_外部纹理;

	C_节点面板::g节点面板构建函数[DEF_外部纹理集节点] = f_节点构建_外部纹理集;
	C_节点面板::g节点面板重置函数[DEF_外部纹理集节点] = f_节点重置_外部纹理集;

	C_节点面板::g节点面板构建函数[DEF_渐变纹理节点] = f_节点构建_渐变纹理;
	C_节点面板::g节点面板重置函数[DEF_渐变纹理节点] = f_节点重置_渐变纹理;
	C_节点面板::g节点面板构建函数[DEF_棋盘格纹理节点] = f_节点构建_棋盘格纹理;
	C_节点面板::g节点面板重置函数[DEF_棋盘格纹理节点] = f_节点重置_棋盘格纹理;

	C_节点面板::g节点面板构建函数[DEF_字符纹理节点] = f_节点构建_字符纹理;
	C_节点面板::g节点面板重置函数[DEF_字符纹理节点] = f_节点重置_字符纹理;

	C_节点面板::g节点面板构建函数[DEF_字符纹理坐标节点] = f_节点构建_字符纹理坐标;
	C_节点面板::g节点面板重置函数[DEF_字符纹理坐标节点] = f_节点重置_字符纹理坐标;

	C_节点面板::g节点面板构建函数[DEF_字符纹理排列节点] = f_节点构建_字符纹理排列;
	C_节点面板::g节点面板重置函数[DEF_字符纹理排列节点] = f_节点重置_字符纹理排列;

	C_节点面板::g节点面板构建函数[DEF_加载纹理节点] = f_节点构建_加载纹理节点;
	C_节点面板::g节点面板重置函数[DEF_加载纹理节点] = f_节点重置_加载纹理节点;

	C_节点面板::g节点面板构建函数[DEF_重置纹理大小节点] = f_节点构建_重置纹理大小;
	C_节点面板::g节点面板重置函数[DEF_重置纹理大小节点] = f_节点重置_重置纹理大小;

	C_节点面板::g节点面板构建函数[DEF_纹理写入文件节点] = f_节点构建_纹理写入文件;
	C_节点面板::g节点面板重置函数[DEF_纹理写入文件节点] = f_节点重置_纹理写入文件;

	C_节点面板::g节点面板构建函数[DEF_噪波纹理节点] = f_节点构建_噪波纹理属性;
	C_节点面板::g节点面板重置函数[DEF_噪波纹理节点] = f_节点重置_噪波纹理属性;
	C_节点面板::g节点面板构建函数[DEF_2D纹理采样节点] = f_节点构建_2D纹理采样;
	C_节点面板::g节点面板重置函数[DEF_2D纹理采样节点] = f_节点重置_2D纹理采样;

	C_节点面板::g节点面板构建函数[DEF_2D纹理数组采样节点] = f_节点构建_2D纹理数组采样;
	C_节点面板::g节点面板重置函数[DEF_2D纹理数组采样节点] = f_节点重置_2D纹理数组采样;

	C_节点面板::g节点面板构建函数[DEF_设置网格材质节点] = f_节点构建_设置物体材质;
	C_节点面板::g节点面板重置函数[DEF_设置网格材质节点] = f_节点重置_设置物体材质;
	
	C_节点面板::g节点面板构建函数[DEF_基于物理计算着色节点] = f_节点构建_基于物理计算着色;
	C_节点面板::g节点面板重置函数[DEF_基于物理计算着色节点] = f_节点重置_基于物理计算着色;
	C_节点面板::g节点面板构建函数[DEF_几何数据节点] = f_节点构建_几何数据;
	C_节点面板::g节点面板重置函数[DEF_几何数据节点] = f_节点重置_几何数据;
	C_节点面板::g节点面板构建函数[DEF_光线数据节点] = f_节点构建_光线数据;
	C_节点面板::g节点面板重置函数[DEF_光线数据节点] = f_节点重置_光线数据;
	C_节点面板::g节点面板构建函数[DEF_几何UV数据节点] = f_节点构建_几何UV数据;
	C_节点面板::g节点面板重置函数[DEF_几何UV数据节点] = f_节点重置_几何UV数据;

	C_节点面板::g节点面板构建函数[DEF_材质器网格自定义属性数据节点] = f_节点构建_材质网格自定义属性数据;
	C_节点面板::g节点面板重置函数[DEF_材质器网格自定义属性数据节点] = f_节点重置_材质网格自定义属性数据;



	//================================= 逻辑 ======================================
	C_节点面板::g节点面板构建函数[DEF_循环节点] = f_节点构建_循环;
	C_节点面板::g节点面板重置函数[DEF_循环节点] = f_节点重置_循环;
	C_节点面板::g节点面板构建函数[DEF_迭代节点] = f_节点构建_迭代;
	C_节点面板::g节点面板重置函数[DEF_迭代节点] = f_节点重置_迭代;
	C_节点面板::g节点面板构建函数[DEF_循环头节点] = f_节点构建_循环迭代;
	C_节点面板::g节点面板重置函数[DEF_循环头节点] = f_节点重置_循环迭代;
	C_节点面板::g节点面板构建函数[DEF_循环尾节点] = f_节点构建_循环尾;
	C_节点面板::g节点面板重置函数[DEF_循环尾节点] = f_节点重置_循环尾;
	C_节点面板::g节点面板构建函数[DEF_输入组节点] = f_节点构建_输入组;
	C_节点面板::g节点面板重置函数[DEF_输入组节点] = f_节点重置_输入组;
	C_节点面板::g节点面板构建函数[DEF_输出组节点] = f_节点构建_输出组;
	C_节点面板::g节点面板重置函数[DEF_输出组节点] = f_节点重置_输出组;
	C_节点面板::g节点面板构建函数[DEF_跳过节点] = f_节点构建_跳过;
	C_节点面板::g节点面板重置函数[DEF_跳过节点] = f_节点重置_跳过;
	C_节点面板::g节点面板构建函数[DEF_Python节点] = f_节点构建_Python;
	C_节点面板::g节点面板重置函数[DEF_Python节点] = f_节点重置_Python;
	C_节点面板::g节点面板构建函数[DEF_分支判断节点] = f_节点构建_分支判断;
	C_节点面板::g节点面板重置函数[DEF_分支判断节点] = f_节点重置_分支判断;
	C_节点面板::g节点面板构建函数[DEF_函数节点] = f_节点构建_函数;
	C_节点面板::g节点面板重置函数[DEF_函数节点] = f_节点重置_函数;
	C_节点面板::g节点面板构建函数[DEF_包节点] = f_节点构建_包;
	C_节点面板::g节点面板重置函数[DEF_包节点] = f_节点重置_包;

	C_节点面板::g节点面板构建函数[DEF_插座转接节点] = f_节点构建_插座转接;
	C_节点面板::g节点面板重置函数[DEF_插座转接节点] = f_节点重置_插座转接;

	C_节点面板::g节点面板构建函数[DEF_面板框节点] = f_节点构建_面板框;
	C_节点面板::g节点面板重置函数[DEF_面板框节点] = f_节点重置_面板框;

	C_节点面板::g节点面板构建函数[DEF_物理几何体节点]      = f_节点构建_物理几何体;
	C_节点面板::g节点面板重置函数[DEF_物理几何体节点]      = f_节点重置_物理几何体;
	C_节点面板::g节点面板构建函数[DEF_物理体节点]          = f_节点构建_物理体;
	C_节点面板::g节点面板重置函数[DEF_物理体节点]          = f_节点重置_物理体;
	C_节点面板::g节点面板构建函数[DEF_物理引擎节点]         = f_节点构建_物理引擎;
	C_节点面板::g节点面板重置函数[DEF_物理引擎节点]         = f_节点重置_物理引擎;
	C_节点面板::g节点面板构建函数[DEF_物理体绑定物体节点]   = f_节点构建_物理体绑定物体节点;
	C_节点面板::g节点面板重置函数[DEF_物理体绑定物体节点]   = f_节点重置_物理体绑定物体节点;
	C_节点面板::g节点面板构建函数[DEF_取物理体节点]         = f_节点构建_取物理体节点;
	C_节点面板::g节点面板重置函数[DEF_取物理体节点]         = f_节点重置_取物理体节点;
	C_节点面板::g节点面板构建函数[DEF_物理引擎内部几何节点] = f_节点构建_物理引擎内部几何节点;
	C_节点面板::g节点面板重置函数[DEF_物理引擎内部几何节点] = f_节点重置_物理引擎内部几何节点;
	C_节点面板::g节点面板构建函数[DEF_应用力节点]           = f_节点构建_物理应用力;
	C_节点面板::g节点面板重置函数[DEF_应用力节点]           = f_节点重置_物理应用力;
	C_节点面板::g节点面板构建函数[DEF_更新肌腱节点]         = f_节点构建_更新肌腱力度;




	//================================ 容器 =========================================

	C_节点面板::g节点面板构建函数[DEF_物体缓存节点]      = f_节点构建_物体缓存;
	C_节点面板::g节点面板重置函数[DEF_物体缓存节点]      = f_节点重置_物体缓存;

	C_节点面板::g节点面板构建函数[DEF_网格缓存写入节点] = f_节点构建_网格缓存写入;
	C_节点面板::g节点面板重置函数[DEF_网格缓存写入节点] = f_节点重置_网格缓存写入;

	C_节点面板::g节点面板构建函数[DEF_读取网格缓存节点] = f_节点构建_读取网格缓存;
	C_节点面板::g节点面板重置函数[DEF_读取网格缓存节点] = f_节点重置_读取网格缓存;



	//============================== 调试 ====================================
	C_节点面板::g节点面板构建函数[DEF_调试输出节点]      = f_节点构建_调试输出;
	C_节点面板::g节点面板重置函数[DEF_调试输出节点]      = f_节点重置_调试输出;

	C_节点面板::g节点面板构建函数[DEF_控制台输出节点] = f_节点构建_控制台输出节点;
	C_节点面板::g节点面板重置函数[DEF_控制台输出节点] = f_节点重置_控制台输出节点;



	f_网格节点_构建函数初始化();
	f_物体节点_构建函数初始化();
	f_计算节点_构建函数初始化();
	f_材质节点_构建函数初始化();
	f_调试节点_构建函数初始化();
	f_渲染节点_构建函数初始化();
	f_变量节点_构建函数初始化();
	f_逻辑节点_构建函数初始化();
	f_容器节点_构建函数初始化();
	f_函数节点_构建函数初始化();
	f_物理节点_构建函数初始化();

}




static bool f_on_1级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"转接") {
		node = f_节点构建_插座转接(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if(name == u"框") {
		node = f_节点构建_面板框(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	if (node) {
		fun_节点视口回调(node, true);
	}
	return false;
}

static bool f_on_1级材质节点菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"自定义参数布局") {
		node = f_节点构建_材质网格自定义属性数据(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else{
		f_on_1级节点创建菜单项(self, name, id);
	}
	if (node) {
		fun_节点视口回调(node, true);
	}
	return false;
}


bool on_2级几何节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	//f_节点面板构建_回调函数指针 create_fn = nullptr;
	C_节点面板* node = nullptr;
	if (name == u"网格") {
		node = f_节点构建_几何网格(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"平面") {
		node = f_节点构建_几何平面(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"球体") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"圆环") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"方体") {
		node = f_节点构建_几何矩形(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"六面") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"线框立方体") {
		node = f_节点构建_线框立方体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"几何") {
		node = f_节点构建_几何(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else {
		if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
			node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
		}
	}
	if (node) {
		fun_节点视口回调(node, true);
	}
	return false;
}

bool on_2创建多边形节点菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;

	if (name == u"平面") {
		node = f_节点构建_几何平面(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"球体") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"圆环") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"方体") {
		node = f_节点构建_几何矩形(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"圆柱") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"圆锥") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"六面") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"几何ID") {
		node = f_节点构建_几何ID(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"当前多边形") {
		node = f_节点构建_当前多边形(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"基本多边形") {
		node = f_节点构建_基本多边形(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"边") {
		node = f_节点构建_多边形边(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"面") {
		node = f_节点构建_多边形面(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"+顶点") {
		node = f_节点构建_多边形添加顶点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"-顶点") {
		node = f_节点构建_多边形删除顶点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"多边形") {
		node = f_节点构建_多边形(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"+UV") {
		node = f_节点构建_添加多边形纹理坐标(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"+元素") {
		node = f_节点构建_添加多边形元素(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取索引") {
		node = f_节点构建_取多边形索引节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取面属性") {
		node = f_节点构建_取多边形面属性节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取多边形元素") {
		node = f_节点构建_取多边形元素(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"设置面属性") {
		node = f_节点构建_设置多边形面属性节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"设置面UV") {
		node = f_节点构建_设置多边形面UV节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"设置材质槽ID") {
		node = f_节点构建_设置面材质槽ID节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"创建属性") {
		node = f_节点构建_创建网格自定义属性节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"设置属性") {
		node = f_节点构建_设置网格自定义属性节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}

bool on_2级灯光节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	f_NodeView_设置当前节点添加_树类型限制(E_节点树类型::e_type_物体节点树);

	C_节点面板* node = nullptr;
	if (name == u"平行光") {
		node = f_节点构建_平行光节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"聚光灯") {
		node = f_节点构建_聚光灯节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"点光源") {
		node = f_节点构建_点光源节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"面光源") {
		node = f_节点构建_面光源节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}

S_菜单创建参数 f_menu参数_灯光() {
	S_菜单创建参数 灯光创建参数 = {
		on_2级灯光节点创建菜单项, {
			{u"平行光",	u"",  u"",0},
			//{u"聚光灯", u"",  u"",0},
			{u"点光源",	u"",  u"",0},
			{u"面光源", u"",  u"",0},
		}
	};
	return 灯光创建参数;
}


static bool f_on_变量2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"引用") {
		node = f_节点构建_变量引用(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"I8变量") {
		node = f_节点构建_I8变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"浮点变量") {
		node = f_节点构建_单值浮点变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"整数变量") {
		node = f_节点构建_单值整数变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"无符号整数") {
		node = f_节点构建_无符号整数变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"线段变量") {
		node = f_节点构建_线段变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"vec3") {
		node = f_节点构建_vec3变量(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"ivec3") {
		node = f_节点构建_ivec3变量(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"vec2") {
		node = f_节点构建_vec2变量(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"[I8]") {
		node = f_节点构建_I8数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"[F32]") {
		node = f_节点构建_F32数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"[I32]") {
		node = f_节点构建_I32数组变量构建(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"[UI32]") {
		node = f_节点构建_UI32数组变量构建(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"[vec2]") {
		node = f_节点构建_vec2数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"[vec3]") {
		node = f_节点构建_vec3数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"[vec4]") {
		node = f_节点构建_vec4数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"[ivec2]") {
		node = f_节点构建_ivec2数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"[ivec3]") {
		node = f_节点构建_ivec3数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"[平面]") {
		node = f_节点构建_平面变量(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"[VecSphere]") {
		node = f_节点构建_VecSphere数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"[构建矩阵]") {
		node = f_节点构建_矩阵构建(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"[线段]") {
		node = f_节点构建_线段1D变量(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"[多边形成员]") {
		node = f_节点构建_多边形成员数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"合并元素") {
		node = f_节点构建_合并数据(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	//else if (name == u"合并数组") {
	//	 node = f_节点构建_矩阵数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境);
	//}
	else if (name == u"转换") {
		node = f_节点构建_转换数据(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"取成员") {
		node = f_节点构建_取成员数据(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"坐标取数据") {
		node = f_节点构建_坐标取数据(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"观察矩阵") {
		node = f_节点构建_观察矩阵构建(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"数组") {
		node = f_节点构建_数组变量(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr); 
	}
	else if (name == u"添加元素") {
		node = f_节点构建_数组添加元素(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"删除元素") {
		node = f_节点构建_删除数组元素(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取元素") {
		node = f_节点构建_取数组元素(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取头尾元素") {
		node = f_节点构建_取数组头尾元素(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"查找元素") {
		node = f_节点构建_查找数组元素(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取内存邻接") {
		node = f_节点构建_取内存邻接数据(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"合并数组") {
		node = f_节点构建_合并数组(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"插入数组") {
		node = f_节点构建_插入数组节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"数组元素统计") {
		node = f_节点构建_数组元素统计(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"复制数组") {
		node = f_节点构建_复制数据(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"数组重排") {
		node = f_节点构建_数组重排(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"数组打乱") {
		node = f_节点构建_数组打乱(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"数组抽取") {
		node = f_节点构建_数组抽取(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取空间邻接") {
		node = f_节点构建_取空间邻接数据(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"文件路径") {
		node = f_节点构建_文件路径节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"行字符串") {
		node = f_节点构建_行字符串(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"行字符串数组") {
		node = f_节点构建_行字符串数组(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"数值转字符串") {
		node = f_节点构建_数值转字符串(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"合并字符串") {
		node = f_节点构建_合并字符串(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"赋值") {
		node = f_节点构建_回写节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else {
		if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
			node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
		}
	}
	if(node) fun_节点视口回调(node, true);
	return false;
}

bool f_on_2级容器节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"点距八叉树") {
		node = f_节点构建_点距八叉树(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"包") {
		node = f_节点构建_包(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"缓存写入") {
		node = f_节点构建_数据缓存写入(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"缓存读取") {
		node = f_节点构建_数据缓存读取(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"物体缓存") {
		node = f_节点构建_物体缓存(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"写网格缓存") {
		node = f_节点构建_网格缓存写入(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"读网格缓存") {
		node = f_节点构建_读取网格缓存(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}

bool f_on_逻辑2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"手动执行") {
		node = f_节点构建_手动执行(*g当前UI环境);
	}
	else if (name == u"循环") {
		C_节点面板* node_头 = f_节点构建_循环(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
		C_节点面板* node_尾 = f_节点构建_循环尾(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
		
		f_配对循环节点头和尾((C_循环节点*)(node_头->m_NodeData), (C_循环尾节点*)(node_尾->m_NodeData));
		std::vector<C_节点面板*> nodes{ node_头, node_尾 };
		fun_创建多节点添加到视口回调(nodes, true);
		return false;
	}
	else if (name == u"迭代") {
		C_节点面板* node_头 = f_节点构建_迭代(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
		//C_节点面板* node_尾 = f_节点构建_循环尾(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);

		//f_配对循环节点头和尾(node_头->m_NodeData, (C_循环尾节点*)(node_尾->m_NodeData));
		//std::vector<C_节点面板*> nodes{ node_头, node_尾 };
		//fun_创建多节点添加到视口回调(nodes, true);
		//return;
		node = node_头;
	}
	else if (name == u"for") {
		node = f_节点构建_循环迭代(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"函数") {
		node = f_节点构建_函数(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr);
	}
	else if (name == u"跳过") {
		node = f_节点构建_跳过(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr);
	}
	else if (name == u"判断") {
		node = f_节点构建_分支判断(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr);
	}
	else if (name == u"End") {
		node = f_节点构建_循环尾(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr);
	}
	else {
		if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
			node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
		}
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}


bool on_2级物体节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"物体集") {
		node = f_节点构建_物体节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	} 
	else if (name == u"摄像机") {
		node = f_节点构建_摄像机节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"目标相机") {
		node = f_节点构建_目标摄像机节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"引用物体") {
		node = f_节点构建_引用物体节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"取物体") {
		node = f_节点构建_取物体节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"查找子物体") {
		node = f_节点构建_查找子物体节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"物体父子关系") {
		node = f_节点构建_物体父子关系节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"设置物体数据") {
		node = f_节点构建_设置物体数据节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"取物体属性") {
		node = f_节点构建_取物体属性节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"取物体变换") {
		node = f_节点构建_取物体变换节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"取物体矩阵") {
		node = f_节点构建_取物体矩阵节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"取物体材质") {
		node = f_节点构建_取物体材质节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"选择物体") {
		node = f_节点构建_选择物体节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"拷贝物体") {
		node = f_节点构建_物体拷贝节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"设置物体矩阵") {
		 node = f_节点构建_设置物体矩阵节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"设置物体变换") {
		node = f_节点构建_设置物体变换节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"设置摄像机") {
		node = f_节点构建_设置摄像机属性节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"物体绑定骨骼") {
		node = f_节点构建_物体绑定骨骼节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"加载物体") {
		node = f_节点构建_外部加载物体节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"加载模型") {
		node = f_节点构建_加载模型节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"骨架") {
		node = f_节点构建_骨骼节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"骨头") {
		node = f_节点构建_骨头节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"IK") {
		node = f_节点构建_骨骼IK节点(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else {
		if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
			node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
		}
	}

	if(node) fun_节点视口回调(node, true);
	return false;
}


bool f_on_场景2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"场景") {
		//auto* node = f_节点构建_视频(*g当前UI环境);
	}
	else if (name == u"时间帧") {
		node = f_节点构建_帧时间(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"射线拾取") {
		node = f_节点构建_射线物体拾取(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"范围拾取") {
		node = f_节点构建_范围拾取(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"OpenVDB网格") {
		node = f_节点构建_OpenVDB网格(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"视口手柄") {
		node = f_节点构建_视口手柄(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}


bool f_on_材质2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"材质") {
		node = f_节点构建_材质槽(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"编辑材质") {
		node = f_节点构建_材质(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"当前材质") {
		node = f_节点构建_当前材质(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"材质组ID") {
		node = f_节点构建_几何ID(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"自发光") {
		node = f_节点构建_自发光材质(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"纹理") {
		node = f_节点构建_纹理(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"噪波纹理") {
		node = f_节点构建_噪波纹理属性(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"渐变纹理") {
		node = f_节点构建_渐变纹理(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"棋盘格") {
		node = f_节点构建_棋盘格纹理(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"外部纹理") {
		node = f_节点构建_外部纹理(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"纹理集") {
		node = f_节点构建_外部纹理集(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"字符纹理") {
		node = f_节点构建_字符纹理(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"字符纹理坐标") {
		node = f_节点构建_字符纹理坐标(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"字符纹理排列") {
		node = f_节点构建_字符纹理排列(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"加载纹理") {
		node = f_节点构建_加载纹理节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"重置纹理大小") {
		node = f_节点构建_重置纹理大小(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"纹理写入文件") {
		node = f_节点构建_纹理写入文件(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"纹理采样") {
		node = f_节点构建_2D纹理采样(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"纹理数组采样") {
		node = f_节点构建_2D纹理数组采样(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"视频") {
		node = f_节点构建_视频(*g当前UI环境);
	}
	else if (name == u"设置材质") {
		node = f_节点构建_设置物体材质(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	//else if (name == u"着色器") {
	//	node = f_节点构建_设置PBR材质属性(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	//}
	else if (name == u"基于物理计算") {
		node = f_节点构建_基于物理计算着色(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else {
		if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
			node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
		}
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}

bool on_颜色2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
		node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}

bool f_on_计算2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"计算") {
		node = f_节点构建_单值计算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"位运算") {
		node = f_节点构建_位运算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	//else if (name == u"逻辑计算") {
	//	node = f_节点构建_逻辑计算节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	//}
	else if (name == u"累计") {
		node = f_节点构建_累计计算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"矢量计算") {
		node = f_节点构建_矢量计算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"单目计算") {
		node = f_节点构建_单目计算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"几何计算") {
		node = f_节点构建_几何计算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"两向量标量") {
		node = f_节点构建_两向量标量计算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"归一化") {
		node = f_节点构建_归一化计算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"长度") {
		node = f_节点构建_向量长度(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"三角函数") {
		node = f_节点构建_三角函数计算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	
	else if (name == u"合并XYZ") {
		node = f_节点构建_合并XYZ(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"分离XYZ") {
		node = f_节点构建_分离XYZ(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"混合") {
		node = f_节点构建_混合(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"矩阵变换") {
		node = f_节点构建_矩阵变换(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"矩阵计算") {
		node = f_节点构建_矩阵计算(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"矩阵转换") {
		node = f_节点构建_矩阵转换(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}

	else if (name == u"向量转四元数") {
		node = f_节点构建_向量转四元数(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"向量角度组成四元数") {
		node = f_节点构建_向量角度组成四元数(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"四元数转欧拉角") {
		node = f_节点构建_四元数转换为欧拉角(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"四元数转矩阵") {
		node = f_节点构建_四元数转换为矩阵节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"顶点矩阵变换") {
		node = f_节点构建_顶点变换(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"点到平面") {
		node = f_节点构建_平面到点节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"平面线段相交") {
		node = f_节点构建_平面线段相交节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"旋转向量") {
		node = f_节点构建_旋转向量节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"轴向旋转") {
		node = f_节点构建_轴向旋转向量节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"绕点旋转") {
		node = f_节点构建_绕点旋转(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	
	else if (name == u"圆坐标生成") {
		node = f_节点构建_圆坐标生成节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"直线") {
		node = f_节点构建_直线(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"渐变") {
		node = f_节点构建_渐变采样(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"钳制") {
		node = f_节点构建_单值钳制(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"矢量钳制") {
		node = f_节点构建_矢量钳制(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"坐标转索引") {
		node = f_节点构建_坐标转索引节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"索引转坐标") {
		node = f_节点构建_索引转坐标节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"步进") {
		node = f_节点构建_步进计算节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"索引数组排序") {
		node = f_节点构建_索引数组排序(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"取空间邻接") {
		node = f_节点构建_取空间邻接数据(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else {
		if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
			node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
		}
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}

bool f_on_并行_2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
		node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}

bool f_on_物理体2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"物理几何") {
		node = f_节点构建_物理几何体(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"物理体") {
		node = f_节点构建_物理体(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"物理引擎") {
		node = f_节点构建_物理引擎(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	} 
	else if (name == u"解算") {
		node = f_节点构建_解算器模拟(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"取物理体") {
		node = f_节点构建_取物理体节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	} 
	else if (name == u"绑定物体") {
		node = f_节点构建_物理体绑定物体节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"应用力") {
		node = f_节点构建_物理应用力(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"更新肌腱") {
		node = f_节点构建_更新肌腱力度(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"PBF解算器") {
		node = f_节点构建_PBF解算器(*g当前UI环境, *S_节点框架::g_3D视口环境);
	}
	else if (name == u"FLIP解算器") {
		node = f_节点构建_FLIP解算器(*g当前UI环境);
	}
	else {
		if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
			node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
		}
	}

	if (node) fun_节点视口回调(node, true);
	return false;
}



bool f_on_网络2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"UDP接收图像") {
		node = f_节点构建_接收UDP图像(*g当前UI环境);
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}



bool f_on_动画2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"非线性轨道") {
		node = f_节点构建_非编轨道(*g当前UI环境, S_节点框架::g_3D视口环境);
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}



bool f_on_2级节点创建脚本(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"函数") {
		node = f_节点构建_函数(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr);
	}
	else if (name == u"程序集") {
		
	}
	else if (name == u"Python") {
		node = f_节点构建_Python(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}



bool f_on_调试2级节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == u"调试输出") {
		node = f_节点构建_调试输出(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else if (name == u"控制台输出") {
		node = f_节点构建_控制台输出节点(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr);
	}
	else {
		if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
			node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
		}
	}
	if (node) fun_节点视口回调(node, true);
	return false;
}


static bool on_2级节点_渲染合成节点创建菜单项(C_Widget* self, const std::u16string name, uint16 id) {
	C_节点面板* node = nullptr;

	if (C_节点面板::g节点构建函数_创建名称对应类型名称.find(name) != C_节点面板::g节点构建函数_创建名称对应类型名称.end()) {
		node = C_节点面板::g节点面板构建函数[C_节点面板::g节点构建函数_创建名称对应类型名称[name]](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
	}

	f_NodeView_设置当前节点添加_树类型限制(E_节点树类型::e_type_物体节点树);
	if (node) fun_节点视口回调(node, true);
	return false;
}




static S_菜单创建参数 f_物体子菜单创建() {
	S_菜单创建参数 创建参数 = {
		f_on_物理体2级节点创建菜单项, {

			{u"点粒子发射体", u"",  u"",0},
			{u"线粒子发射体", u"",  u"",0},
			{u"平面粒子发射体", u"",  u"",0},
			{u"方体粒子发射体", u"",  u"",0},
			{u"网格粒子发射体", u"",  u"",0},
			//{u"网格粒子发射体", "", 0},
		}
	};


	return 创建参数;
}


//static S_菜单创建参数 物体创建参数 = {
//	on_2级物体节点创建菜单项, {
//		{u"物体集", u"",  u"",0},
//		{u"取物体", u"zoom",  u"",0},
//		{u"查找子物体", u"zoom",  u"",0},
//		{u"引用物体", u"链接",  u"",0},
//
//	{u"", u"",  u"",0},
//		{u"摄像机", u"摄像机",  u"",0},
//		{u"目标相机", u"目标相机",  u"",0},
//		{u"虚拟体", u"",  u"",0},
//		{u"天空", u"",  u"",0},
//
//	{u"", u"",  u"",0},
//		{u"加载物体", u"加载物体",  u"",0},
//		{u"加载模型", u"打开文件夹",  u"",0},
//
//	//{u"", "", 0},
//		//{u"物体父子关系", "", 0},
//		//{u"设置物体数据", "", 0},
//
//	{u"", u"",  u"",0},
//		{u"取物体变换", u"",  u"",0},
//		{u"设置物体变换", u"",  u"",0},
//
//		{u"取物体矩阵", u"",  u"",0},
//		{u"设置物体矩阵", u"",  u"",0},
//		
//		{u"设置摄像机", u"",  u"",0},
//		{u"设置物体中心", u"",  u"",0},
//		{u"设置物体法线", u"",  u"",0},
//		{u"物体绕轴旋转", u"",  u"",0},
//		{u"设置物体缩放", u"",  u"",0},
//		{u"设置绘制模式", u"",  u"",0},
//		{u"物体对称", u"物体对称",  u"",0},
//
//	{u"", u"",  u"",0},
//		//{u"取物体材质", "", 0},
//		//{u"取光追材质", "", 0},
//		
//		{u"选择物体", u"选择",  u"",0},
//		{u"拷贝物体", u"clipboard_copy",  u"",0},
//		{u"创建物体实例", u"",  u"",0},
//		//{u"取物体属性", "", 0},
//
//	{u"", u"",  u"",0},
//		//{u"物体绑定骨骼", "", 0},
//		{u"骨架", u"骨架",  u"",0},
//		{u"骨头", u"骨骼",  u"",0},
//		{u"IK", u"", 0},
//		{u"骨骼蒙皮", u"",  u"",0},
//	}
//};

//static S_菜单创建参数 g可编译_物体创建参数 = {
//		on_2级物体节点创建菜单项, {
//			//{u"空物体", "", 0},
//			{u"取物体", u"zoom",  u"",0},
//			{u"引用物体", u"链接",  u"",0},
//			{u"摄像机", u"摄像机",  u"",0},
//		{u"", u"", 0},
//			{u"加载模型", u"打开文件夹",  u"",0},
//		}
//};

static S_菜单创建参数 g基本几何体创建参数 = {
	on_2级几何节点创建菜单项, {
		//{u"网格", "三角网格", 0},
		{u"平面", u"矩形线框",  u"",0},
		{u"球体", u"圆形线框",  u"",0},
		//{u"圆环", "", 0},
		{u"方体", u"立体线框",  u"",0},
		{u"圆柱", u"圆柱",  u"",0},
		{u"圆锥", u"",  u"",0},
		{u"u板", u"",  u"",0},
		//{u"线框立方体", "四边顶点", 0},
		{u"", u"",  u"",0},

		{u"曲线", u"",  u"",0},

		{u"", u"",  u"",0},

		{u"几何", u"几何",  u"",0},
	}
};

//static S_菜单创建参数 g可编译_多边形节点创建参数 = {
//	on_2创建多边形节点菜单项, {
//		//{u"网格", "三角网格", 0},
//		{u"几何ID", u"指示ID",  u"",0},
//		{u"当前多边形", u"",  u"",0},
//		{u"基本多边形", u"矩形线框",  u"",0},
//		
//		{u"+顶点", u"", u"", 0},
//	//{u"-顶点", ", 0"},
//		{u"+UV", u"",  u"",0},
//	//{u"-UV", ", 0"},
//		{u"+元素", u"四边顶点",  u"",0},
//
//		{u"边", u"直线顶点",  u"",0},
//		{u"面", u"四边顶点",  u"",0},
//		
//	{u"", u"", 0},
//		{u"取索引", u"",  u"",0},
//		{u"取面属性", u"",  u"",0},
//		{u"取多边形元素", u"",  u"",0},
//	{u"", u"", 0},
//		{u"设置面属性", u"",  u"",0},
//		{u"设置面UV", u"",  u"",0},
//		{u"设置材质槽ID", u"材质ID",  u"",0},
//
//	{u"", u"", 0},
//		{u"创建属性", u"",  u"",0},
//		{u"设置属性", u"",  u"",0},
//	}
//};

static S_菜单创建参数 g可编译_函数_几何网格节点创建参数 = {
	on_2创建多边形节点菜单项, {
		//{u"网格", "三角网格", 0},
		{u"基本多边形", u"矩形线框",  u"",0},

		{u"+顶点", u"",  u"",0},
	//{u"-顶点", ", 0"},
		{u"+UV", u"",  u"",0},
	//{u"-UV", ", 0"},
		{u"+元素", u"四边顶点",  u"",0},

		{u"边", u"直线顶点",  u"",0},
		{u"面", u"四边顶点",  u"",0},

	{u"", u"",  u"", 0},
		{u"取索引", u"",  u"",0},
		{u"取面属性", u"",  u"",0},
		{u"取多边形元素", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"设置面属性", u"",  u"",0},
		{u"设置面UV", u"",  u"",0},
		{u"设置材质槽ID", u"材质ID",  u"",0},
	}
};

static S_菜单创建参数 g网格参数 = {
	f_on_网格2级节点创建菜单项, {
		{u"边采样", u"",  u"",0},
		{u"设置平滑模式", u"",  u"",0},

	{u"", u"",  u"",0},
		//{u"网格", "", 0},
		//{u"面朝向", "", 0},
		//{u"设置材质", "", 0},
		//{u"从网格构建体素", "", 0},
		//{u"网格采样", "", 0},
		//{u"计算法线", "", 0},
		//{u"截取网格", "", 0},
		//{u"网格属性", "", 0},
		//{u"填充顶点", "", 0},
		//{u"填充纹理坐标", "", 0},
		//{u"填充索引", "", 0},

	{u"", u"",  u"",0},
		{u"多边形桥接", u"",  u"",0},
		{u"多边形转网格", u"",  u"",0},
		
	{u"", u"",  u"",0},
		{u"取模型元素", u"",  u"",0},
		{u"取多边形顶点", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"取网格元素顶点", u"",  u"",0},
		{u"设置网格元素顶点", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"取多边形边", u"",  u"",0},
	}
};

//static S_菜单创建参数 g可编译_网格参数 = {
//	f_on_网格2级节点创建菜单项, {
//		{u"边采样", u"",  u"",0},
//		{u"多边形桥接", u"",  u"",0},
//		{u"点桥接", u"",  u"",0},
//		{u"边实体化", u"",  u"",0},
//		{u"变换多边形", u"移动",  u"",0},
//		{u"设置平滑模式", u"",  u"",0},
//
//	{u"", u"",  u"",0},
//		{u"复制多边形", u"clipboard_copy",  u"",0},
//		{u"拷贝多边形", u"拷贝文件",  u"",0},
//		
//		{u"投影坐标", u"",  u"",0},
//	{u"", u"",  u"",0},
//		{u"取多边形面顶点", u"",  u"",0},
//		{u"设置多边形面顶点", u"",  u"",0},
//		
//	{u"", u"", 0},
//		{u"取网格元素顶点", u"",  u"",0},
//		{u"设置网格元素顶点", u"",  u"",0},
//
//	{u"", u"",  u"",0},
//		{u"取多边形边", u"",  u"",0},
//	}
//};

S_菜单创建参数 g可编译_场景创建参数 = {
	f_on_场景2级节点创建菜单项, {
		//{u"场景", "font-448", 0},
		{u"时间帧", u"font-448",  u"",0},
		//{u"射线拾取", "font-257", 0},
		//{u"范围拾取", "font-257", 0},
		//{u"OpenVDB网格", "font-257", 0},
		//{u"视口手柄", "font-257", 0},
	}
};

//static S_菜单创建参数 g变量创建参数 = {
//	f_on_变量2级节点创建菜单项, {
//		{u"浮点变量", u"",  u"",0},
//		{u"整数变量", u"",  u"",0},
//		{u"I8变量", u"",  u"",0},
//		{u"线段变量", u"",  u"",0},
//
//	{u"", u"",  u"",0},
//		{u"vec3", u"",  u"",0},
//		{u"vec2", u"",  u"",0},
//		{u"ivec3", u"",  u"",0},
//		
//		{u"包围盒", u"",  u"",0},
//
//	{u"", u"",  u"",0},
//		{u"[I8]", u"",  u"",0},
//		{u"[I32]", u"",  u"",0},
//		{u"[F32]", u"",  u"",0},
//
//	{u"", u"",  u"",0},
//		{u"[vec2]", u"",  u"",0},
//		{u"[vec3]", u"",  u"",0},
//		{u"[ivec2]", u"",  u"",0},
//		{u"[ivec3]", u"",  u"",0},
//		{u"[矩阵]", u"",  u"",0},
//		{u"[VecSphere]", u"",  u"",0},
//		{u"[平面]", u"",  u"",0},
//
//	{u"", u"", 0},
//		{u"[构建矩阵]", u"",  u"",0},
//		{u"观察矩阵", u"",  u"",0},
//		{u"[线段]", u"",  u"",0},
//		{u"[包围盒]", u"",  u"",0},
//
//	{u"", u"", 0},
//		{u"合并元素", u"",  u"",0},
//		{u"合并数组", u"",  u"",0},
//		{u"添加元素", u"",  u"",0},
//		//{u"插入元素", "", 0},
//		{u"删除元素", u"",  u"",0},
//		{u"数组属性", u"",  u"",0},
//		
//		{u"复制数组", u"",  u"",0},
//		{u"取元素", u"",  u"",0},
//		{u"绑定索引", u"",  u"",0},
//
//		{u"转换", u"",  u"",0},
//		{u"取成员", u"",  u"",0},
//		{u"坐标取数据", u"",  u"",0},
//
//	{u"", u"",  u"",0},
//		{u"取空间邻接", u"",  u"",0},
//
//	{u"", u"", 0},
//		{u"文件路径", u"",  u"",0},
//		{u"行字符串", u"",  u"",0},
//		{u"行字符串数组", u"",  u"",0},
//		{u"合并字符串", u"",  u"",0},
//		{u"数值转字符串", u"",  u"",0},
//	}
//};

/*static S_菜单创建参数 g变量创建参数_可编译 = {
	f_on_变量2级节点创建菜单项, {
		{u"赋值", u"",  u"",0},
		{u"切换", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"引用", u"",  u"",0},
		{u"浮点变量", u"",  u"",0},
		{u"整数变量", u"",  u"",0},
		{u"无符号整数", u"",  u"",0},
		{u"I8变量", u"",  u"",0},

		{u"vec3", u"",  u"",0},
		{u"vec2", u"",  u"",0},
		{u"ivec3", u"",  u"",0},
		{u"包围盒", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"[I8]", u"",  u"",0},
		{u"[F32]", u"",  u"",0},
		{u"[I32]", u"",  u"",0},
		{u"[UI32]", u"", u"", 0},
		
	{u"", u"", 0},
		{u"[vec2]", u"",  u"",0},
		{u"[vec3]", u"",  u"",0},
		{u"[vec4]", u"",  u"",0},
		{u"[ivec2]", u"",  u"",0},
		{u"[ivec3]", u"",  u"",0},
		{u"[平面]", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"[多边形成员]", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"矩阵", u"",  u"",0},
		{u"[构建矩阵]", u"",  u"",0},
		{u"观察矩阵", u"",  u"",0},
		{u"[包围盒]", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"合并元素", u"",  u"",0},
		//{u"合并数组", "", 0},
		{u"数组", u"",  u"",0},
		{u"添加元素", u"",  u"",0},
		{u"删除元素", u"",  u"",0},
		{u"数组属性", u"",  u"",0},
		{u"取元素", u"",  u"",0},
		{u"取头尾元素", u"",  u"",0},
		{u"查找元素", u"放大镜",  u"",0},
		{u"合并数组", u"",  u"",0},
		{u"复制数组", u"clipboard_copy",  u"",0},
		{u"数组重排", u"重排",  u"",0},
		{u"数组元素统计", u"",  u"",0},

		{u"取内存邻接", u"",  u"",0},
		
		{u"插入数组", u"",  u"",0},
		{u"数组打乱", u"",  u"",0},
		{u"数组抽取", u"",  u"",0},
		{u"绑定索引", u"",  u"",0},
		{u"填充数组", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"取空间邻接", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"文件路径", u"",  u"",0},
		{u"行字符串", u"",  u"",0},
		{u"合并字符串", u"",  u"",0},
		{u"数值转字符串", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"取体素属性", u"",  u"",0},
		{u"设置体素属性", u"",  u"",0},
	}
};*/

/*static S_菜单创建参数 g变量创建参数_着色器 = {
	f_on_变量2级节点创建菜单项, {
		{u"浮点变量", u"", 0},
		{u"整数变量", u"", 0},

	{u"", u"", 0},
		{u"vec3", u"", 0},
		{u"vec2", u"", 0},
		{u"ivec3", u"", 0},

	{u"", u"", 0},
		{u"[vec2]", u"", 0},
		{u"[vec3]", u"", 0},
		{u"[vec4]", u"", 0},
		{u"[平面]", u"", 0},
	{u"", u"", 0},
		{u"矩阵", u"", 0},
		{u"[构建矩阵]", u"", 0},
		//{u"观察矩阵", "", 0},

		{u"", u"", 0},

		{u"数组", u"", 0},
		{u"添加元素", u"", 0},
		{u"数组属性", u"", 0},
		{u"取元素", u"", 0},
		{u"合并数组", u"", 0},

		{u"取内存邻接", u"", 0},
		{u"取空间邻接", u"", 0},
		{u"插入数组", u"", 0},
	}
};*/

/*static S_菜单创建参数 g计算创建参数 = {
	f_on_计算2级节点创建菜单项, {

		{u"计算",		u"", 0},
		{u"逻辑计算",	u"", 0},
		{u"单目计算",	u"", 0},
		{u"混合",		u"", 0},
		//{u"曲线采样", "", 0},

	{u"", u"", 0},
		{u"矢量计算", u"", 0},
		{u"几何计算", u"", 0},
		{u"三角函数", u"", 0},
		
		{u"两向量标量", u"", 0},
		{u"归一化", u"", 0},
		{u"长度", u"", 0},
		
		{u"旋转向量", u"", 0},
		{u"轴向旋转向量", u"", 0},
		{u"向量转四元数", u"", 0},

		{u"点到平面", u"平面法线", 0},

	{u"", u"", 0},
		{u"合并XYZ", u"", 0},
		{u"分离XYZ", u"", 0},
		{u"矢量统计", u"", 0},
		{u"设置分量", u"", 0},
		{u"取矢量分量", u"", 0},

	{u"", u"", 0},
		
		{u"射线相交", u"", 0},
		{u"包围检测", u"", 0},
		{u"体素统计", u"", 0},
		{u"空间邻近", u"", 0},

	{u"", u"", 0},
		{u"矩阵变换", u"", 0},
		{u"矩阵计算", u"", 0},
		{u"矩阵转换", u"", 0},

	{u"", u"", 0},
		{u"四元数计算", u"", 0},
		{u"四元数变换", u"", 0},
		{u"向量角度组成四元数", u"", 0},
		{u"四元数转欧拉角", u"", 0},
		{u"四元数转矩阵", u"", 0},

	{u"", u"", 0},
		{u"顶点矩阵变换", u"", 0},
		
		
	{u"", u"", 0},
		{u"圆坐标生成", u"圆形", 0},
		{u"直线", u"直线", 0},
		{u"体素坐标", u"点阵", 0},
		{u"渐变", u"曲线编辑", 0},

	{u"", u"", 0},
		//{u"坐标转索引", "", 0},
		//{u"索引转坐标", "", 0},
		{u"步进", u"", 0},
	}
};*/

/*static S_菜单创建参数 g计算创建参数_可编译 = {
	f_on_计算2级节点创建菜单项, {

		{u"计算",		u"", 0},
		{u"逻辑计算",	u"", 0},
		{u"单目计算",	u"", 0},
		{u"位运算",		u"", 0},
		{u"混合",		u"", 0},
		{u"累计",		u"", 0},
		//{u"曲线采样", "", 0},

	{u"", u"", 0},
		{u"矢量计算",	u"", 0},
		{u"两向量标量", u"", 0},
		{u"归一化",		u"", 0},
		{u"长度",		u"", 0},
		{u"三角函数", u"", 0},
		{u"旋转向量", u"", 0},
		{u"轴向旋转", u"", 0},
		{u"绕点旋转", u"", 0},
		{u"线段方向", u"", 0},

		{u"点到平面",     u"平面法线", 0},
		{u"平面线段相交", u"线平面相交", 0},

	{u"", u"", 0},
		{u"合并XYZ",	u"", 0},
		{u"分离XYZ",	u"", 0},
		{u"设置分量",	u"", 0},
		{u"取矢量分量",	u"", 0},

	{u"", u"", 0},
		{u"矢量统计", u"", 0},
		{u"包围检测", u"", 0},
		{u"体素统计", u"", 0},
		{u"空间邻近", u"", 0},

	{u"", u"", 0},
		{u"矩阵变换", u"", 0},
		{u"矩阵计算", u"", 0},
		{u"顶点矩阵变换", u"", 0},
	{u"", u"", 0},
		{u"向量转四元数", u"", 0},
		{u"向量角度组成四元数", u"", 0},
		{u"四元数计算", u"", 0},
		{u"四元数变换", u"", 0},
		{u"四元数转欧拉角", u"", 0},
		{u"四元数转矩阵", u"", 0},
	{u"", u"", 0},
		
		{u"钳制", u"", 0},
		{u"矢量钳制", u"", 0},
	{u"", u"", 0},
		{u"圆坐标生成", u"圆形", 0},
		{u"直线", u"直线", 0},
		{u"体素坐标", u"点阵", 0},
		{u"渐变", u"曲线编辑", 0},

	{u"", u"", 0},
		{u"坐标转索引", u"", 0},
		{u"索引转坐标", u"", 0},
		{u"步进", u"", 0},
		{u"索引数组排序", u"重排", 0},
		{u"取空间邻接", u"", 0},
	}
};*/


/*static S_菜单创建参数 g逻辑创建参数 = {
	f_on_逻辑2级节点创建菜单项, {
		//{u"手动执行", "", 0},
		//{u"if_else", "", 0},
		//{u"for", "循环", 0},
		
		{u"函数",		u"", 0},
		{u"轨道采样",	u"", 0},
	}
};*/

/*static S_菜单创建参数 g可编译_逻辑创建参数 = {
	f_on_逻辑2级节点创建菜单项, {
		{u"判断", u"",  u"",0},
		{u"循环", u"循环",  u"",0},
		{u"迭代", u"迭代",  u"",0},
		{u"多维循环", u"",  u"",0},
		{u"并行", u"",  u"",0},
		{u"跳过", u"返回",  u"",0},
		{u"函数", u"", u"", 0},
		{u"轨道采样", u"",  u"",0},
		{u"End", u"",  u"",0},
	}
};*/

/*static S_菜单创建参数 g着色器_逻辑菜单项 = {
	f_on_逻辑2级节点创建菜单项, {
		//{u"判断", "", 0},
		//{u"循环", "循环", 0},
		//{u"迭代", "迭代", 0},
		//{u"多维循环", "", 0},
		{u"线程ID", u"", 0},
		//{u"跳过", "返回", 0},
		//{u"函数", "", 0},
		//{u"轨道采样", "", 0},
		//{u"End", "", 0},
	}
};*/

/*static S_菜单创建参数 g材质创建参数 = {
	f_on_材质2级节点创建菜单项, {
		{u"材质", u"", 0},
		{u"编辑材质", u"球", 0},
		//{u"PBR", "", 0},
	{u"", u"", 0},
		{u"纹理", u"图像", 0},
		{u"外部纹理", u"font-451", 0},
		{u"从文件填充纹理", u"font-451", 0},
		{u"纹理集", u"图像集", 0},
		{u"噪波纹理", u"", 0},
		{u"字符纹理", u"", 0},

	{u"", u"", 0},
		{u"加载纹理", u"", 0},
		{u"重置纹理大小", u"", 0},
		{u"纹理写入文件", u"", 0},
		{u"取纹理属性", u"", 0},
		
	{u"", u"", 0},
		{u"设置材质", u"", 0},
		{u"设置实例材质", u"", 0},

	{u"", u"", 0},
		{u"瓦片坐标", u"", 0},
	}
};*/

/*static S_菜单创建参数 g可编译_材质创建参数 = {
	f_on_材质2级节点创建菜单项, {
		//{u"着色器", "", 0},
		{u"当前材质", u"球", 0},
		{u"材质组ID", u"指示ID", 0},

	{u"", u"", 0},
		{u"像素着色器", u"", 0},
		{u"几何着色器", u"", 0},

	{u"", u"", 0},
		{u"外部纹理", u"font-451", 0},
		{u"纹理", u"图像", 0},
		//{u"过程纹理", "", 0},
		//{u"设置材质", "", 0},
		//{u"字符纹理坐标", ""},
	}
};*/


static S_菜单创建参数 g可编译_着色器创建参数 = {
	f_on_材质2级节点创建菜单项, {
		{u"基于物理计算", u"",  u"",0},
		{u"自发光", u"",  u"",0},
	}
};

static S_菜单创建参数 g可编译_着色器纹理创建参数 = {
	f_on_材质2级节点创建菜单项, {
		{u"外部纹理", u"",  u"",0},
		//{u"纹理", "", 0},
		{u"噪波纹理", u"",  u"",0},
		{u"渐变纹理", u"",  u"",0},
		{u"棋盘格", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"纹理采样", u"",  u"",0},
		{u"纹理数组采样", u"",  u"",0},

	{u"", u"",  u"",0},
		{u"瓦片坐标", u"",  u"",0},
	}
};

static S_菜单创建参数 g可编译_着色器颜色创建参数 = {
	on_颜色2级节点创建菜单项, {
		{u"色相饱和度", u"",  u"",0},
	}
};


/*static S_菜单创建参数 g可编译_材质纹理创建参数 = {
	f_on_材质2级节点创建菜单项, {
		{u"纹理", u"图像", 0},
		{u"噪波纹理", u"", 0},
		//{u"渐变纹理", "", 0},
		//{u"棋盘格", "", 0},
	{u"", u"", 0},
		{u"外部纹理", u"font-451", 0},
		{u"纹理集", u"图像集", 0},
		{u"加载纹理", u"", 0},
		{u"重置纹理大小", u"", 0},
		{u"纹理写入文件", u"", 0},
		{u"取纹理属性", u"", 0},

	{u"", u"", 0},
		{u"字符纹理坐标", u""},
		{u"字符纹理排列", u""},

	{u"", u"", 0},
		{u"瓦片坐标", u"", 0},
	}
};*/


/*static S_菜单创建参数 g调试创建参数 = {
	f_on_调试2级节点创建菜单项, {
		{u"数值标注", u"", 0},
		{u"几何预览", u"几何", 0},
	}
};

static S_菜单创建参数 g调试创建参数_可编译 = {
	f_on_调试2级节点创建菜单项, {
		{u"控制台输出", u"app_window_shell", 0},
	}
};

static S_菜单创建参数 g场景创建参数_可编译 = {
	f_on_场景2级节点创建菜单项, {

		{u"时间帧", u"font-448", 0},
	}
};

static S_菜单创建参数 g并行_笔刷 = {
	f_on_并行_2级节点创建菜单项, {
		{u"毛笔笔刷", u"", 0},
		{u"设置纹理", u"", 0},
	}
};*/


C_Widget* f_init物体节点创建菜单(S_UI渲染环境& ctx) {
	S_菜单创建参数 菜单创建参数;

	g当前UI环境 = &ctx;
	

	/*S_菜单创建参数 容器创建参数 = {
		f_on_2级容器节点创建菜单项, {
			{u"缓存写入", u"", 0},
			{u"缓存读取", u"", 0},

		{u"", u"", 0},
			{u"物体缓存", u"", 0},

		{u"", u"", 0},
			{u"写网格缓存", u"存入", 0},
			{u"读网格缓存", u"取出", 0},
		}
	};

	

	S_菜单创建参数 场景创建参数 = {
		f_on_场景2级节点创建菜单项, {
			{u"时间帧", u"font-448", 0},
		}
	};



	S_菜单创建参数 物理创建参数 = {
		f_on_物理体2级节点创建菜单项, {
			{u"物理几何", u"", 0},
			{u"物理体", u"", 0},
			{u"物理引擎", u"", 0},
			{u"力", u"", 0},
			//{u"PBF解算器", "", 0},
			{u"PBF参数", u"", 0},
			
		//{u"取物理体", ", 0"},
		//{u"绑定物体", ", 0"},
			
			{u"解算", u"", 0},
		//{u"更新肌腱", "", 0},
		{u"",		u"", 0},
			{u"粒子系统",	u"", 0},
			{u"粒子发射",	u"", 0},
		//	{u"发射", "", 0},
		//	{u"单方向力", "", 0},
		}
	};

	S_菜单创建参数 网络创建参数 = {
		f_on_网络2级节点创建菜单项, {

			{u"UDP接收图像", u"", 0},

		}
	};

	S_菜单创建参数 动画创建参数 = {
		f_on_动画2级节点创建菜单项, {

			{u"非线性轨道", u"", 0},

		}
	};

	S_菜单创建参数 设备创建参数 = {
		f_on_1级节点创建菜单项, {

			{u"XBOX控制器", u"", 0},
			//{u"Kinect", "", 0},
			//{u"点光", "", 0},
		}
	};

	S_菜单创建参数 渲染合成创建参数 = {
		on_2级节点_渲染合成节点创建菜单项, {
			{u"光栅阴影", u"", 0},
			{u"光栅环境", u"", 0},
			{u"光栅渲染", u"", 0},
		}
	};*/

	

	auto 灯光项 = f_menu参数_灯光();

	菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			//{u"几何", u"三角网格",		&g基本几何体创建参数},
			
			//{u"物体", u"font-123",		&物体创建参数},
			//{u"网格", u"三角顶点",		&g网格参数},
			//{u"灯光", u"光",				&灯光项},
			//{u"场景", u"font-448",		&场景创建参数},

			//{u"材质", u"sphere",			&g材质创建参数},
			//{u"变量", u"font-355",		&g变量创建参数},
			//{u"容器", u"二叉树",			&容器创建参数},
			//{u"计算", u"mathematics5",	&g计算创建参数},
			//{u"逻辑", u"font-409",		&g逻辑创建参数},
			//{u"物理", u"orbital",		&物理创建参数},
			//{u"文件", "pack_file", 0},
			//{u"合成", u"layers_1",		&渲染合成创建参数},
			//{u"网络", "network30", &网络创建参数},
			//{u"动画", "movie", &动画创建参数},
			//{u"设备", u"设备",			&设备创建参数},
			//{u"脚本", "network30",	&脚本创建参数},
			//{u"调试",	u"info",			&g调试创建参数},
			//{u"转接",	u"转接",			0},
			//{u"框",		u"框",				0},
		}
	};

	auto* menu = f_ui_创建菜单(ctx, e_纵向, 菜单创建参数, true);

	//f_ui_添加菜单搜素项(menu, g基本几何体创建参数);
	//f_ui_添加菜单搜素项(menu, 物体创建参数);
	//f_ui_添加菜单搜素项(menu, g网格参数);
	//f_ui_添加菜单搜素项(menu, 灯光项);
	//f_ui_添加菜单搜素项(menu, 场景创建参数);
	//f_ui_添加菜单搜素项(menu, g材质创建参数);
	//f_ui_添加菜单搜素项(menu, g变量创建参数);
	//f_ui_添加菜单搜素项(menu, 容器创建参数);
	//f_ui_添加菜单搜素项(menu, g计算创建参数);
	//f_ui_添加菜单搜素项(menu, g逻辑创建参数);
	//f_ui_添加菜单搜素项(menu, 物理创建参数);
	//f_ui_添加菜单搜素项(menu, 设备创建参数);
	//f_ui_添加菜单搜素项(menu, g调试创建参数);



	//std::vector<std::u16string> 项名称 = { u"物体", u"插件" };
	//f_ui_get子菜单项(menu, { u"物体", u"插件" }, true);

	return menu;
}








C_Widget* f_init多边形节点创建菜单(S_UI渲染环境& ctx) {

	S_菜单创建参数 菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			//{u"几何", u"三角网格",u"", 		&g可编译_多边形节点创建参数},
			//{u"网格", u"三角顶点",u"", 		&g可编译_网格参数},
			//{u"物体", u"物体",	u"", 		&g可编译_物体创建参数},
			
			//{u"变量", u"font-355",u"", 		&g变量创建参数_可编译},
			//{u"容器", "二叉树",		&容器创建参数},
			//{u"计算", u"mathematics5",	u"", 	&g计算创建参数_可编译},
			//{u"逻辑", u"font-409",		u"", 	&g可编译_逻辑创建参数},
			
			//{u"纹理", u"图像",	u"", 		&g可编译_材质纹理创建参数},

			//{u"文件", u"pack_file",	u"", 	0},
			//{u"场景", u"font-448",	u"", 	&g可编译_场景创建参数},
			
			//{u"动画", "movie", &动画创建参数},
			//{u"脚本", "network30", &脚本创建参数},
			//{u"调试", u"info",	u"", 		&g调试创建参数_可编译},
			//{u"转接", u"转接",	u"", 		0},
			{u"框", u"框",		u"", 		0},
		}
	};

	//auto* menu = f_ui_创建菜单(ctx, e_纵向, 菜单创建参数, true);

	//f_ui_添加菜单搜素项(menu, g可编译_多边形节点创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_网格参数);
	//f_ui_添加菜单搜素项(menu, g可编译_物体创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_物体创建参数);
	//f_ui_添加菜单搜素项(menu, g变量创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g计算创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g可编译_逻辑创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_场景创建参数);
	//f_ui_添加菜单搜素项(menu, g调试创建参数_可编译);
	return nullptr;
}

C_Widget* f_init材质节点创建菜单(S_UI渲染环境& ctx) {
	S_菜单创建参数 菜单创建参数 = {
		f_on_1级材质节点菜单项, {
			//{u"变量", u"font-355", u"", &g变量创建参数_可编译},
			//{u"计算", u"mathematics5", u"", &g计算创建参数_可编译},
			//{u"逻辑", u"font-409", u"", &g可编译_逻辑创建参数},
			//{u"着色", u"sphere", u"", &g可编译_材质创建参数},
			//{u"纹理", u"图像", u"", &g可编译_材质纹理创建参数},

		{u"", u"", 0},
			{u"自定义参数布局", u"", u"", 0},

		{u"", u"", 0},
			//{u"场景", u"", u"", &g场景创建参数_可编译},

		{u"", u"", 0},
			//{u"调试", u"info", u"", &g调试创建参数_可编译},
			{u"转接", u"转接", u"", 0},
			{u"框", u"框", u"", 0},
		}
	};

	auto* menu = f_ui_创建菜单(ctx, e_纵向, 菜单创建参数, true);

	//f_ui_添加菜单搜素项(menu, g变量创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g计算创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g可编译_逻辑创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_材质创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_材质纹理创建参数);
	//f_ui_添加菜单搜素项(menu, g场景创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g调试创建参数_可编译);
	return menu;
}

C_Widget* f_init着色器节点创建菜单(S_UI渲染环境& ctx) {
	S_菜单创建参数 菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			//{u"几何", u"三角顶点", u"", &g可编译_材质几何数据},
			//{u"变量", u"font-355", u"", &g变量创建参数_着色器},
			//{u"计算", u"mathematics5", u"", &g计算创建参数_可编译},
			//{u"逻辑", u"font-409", u"", &g可编译_逻辑创建参数},
			//{u"着色", u"font-409", u"", &g可编译_着色器创建参数},
			//{u"纹理", u"font-409", u"", &g可编译_着色器纹理创建参数},
			//{u"颜色", u"font-409", u"", &g可编译_着色器颜色创建参数},
			//{u"转接", u"转接", u"", 0},
			{u"框",	u"框", u"", 0},
		}
	};

	auto* menu = f_ui_创建菜单(ctx, e_纵向, 菜单创建参数, true);

	//f_ui_添加菜单搜素项(menu, g可编译_材质几何数据);
	//f_ui_添加菜单搜素项(menu, g变量创建参数_着色器);
	//f_ui_添加菜单搜素项(menu, g计算创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g可编译_逻辑创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_着色器创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_着色器纹理创建参数);
	return menu;
}

C_Widget* f_init几何着色器节点创建菜单(S_UI渲染环境& ctx) {
	S_菜单创建参数 菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			//{u"几何", u"三角顶点", u"", &g可编译_材质几何数据},
			//{u"变量", "font-355", &g变量创建参数_着色器},
			//{u"计算", u"mathematics5", u"", &g计算创建参数_可编译},
			//{u"逻辑", "font-409", &g可编译_逻辑创建参数},
			//{u"元素", u"font-409", u"", &g可编译_几何着色元素菜单项},
			//{u"纹理", u"font-409", u"", &g可编译_着色器纹理创建参数},
			{u"转接", u"转接", u"", 0},
			{u"框", u"框", u"", 0},
		}
	};

	auto* menu = f_ui_创建菜单(ctx, e_纵向, 菜单创建参数, true);

	//f_ui_添加菜单搜素项(menu, g可编译_材质几何数据);
	//f_ui_添加菜单搜素项(menu, g变量创建参数_着色器);
	//f_ui_添加菜单搜素项(menu, g计算创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g可编译_逻辑创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_着色器创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_着色器纹理创建参数);
	return menu;
}

C_Widget* f_init函数节点创建菜单(S_UI渲染环境& ctx) {
	S_菜单创建参数 菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			//{u"物体", u"物体", u"", &g可编译_物体创建参数},
			{u"几何", u"三角网格", u"", &g可编译_函数_几何网格节点创建参数},
			//{u"网格", u"三角顶点", u"", &g可编译_网格参数},

			//{u"变量", u"font-355", u"", &g变量创建参数_可编译},
			//{u"计算", u"mathematics5", u"", &g计算创建参数_可编译},
			//{u"逻辑", u"font-409", u"", &g可编译_逻辑创建参数},
			//{u"材质", u"sphere", u"", &g材质创建参数},
			//{u"纹理", u"图像", u"", &g可编译_材质纹理创建参数},
			//{u"笔刷", u"pack_file", u"", &g并行_笔刷},

			{u"文件", u"pack_file", u"", 0},

			//{u"调试", u"info", u"", &g调试创建参数_可编译},
			{u"转接", u"转接", u"", 0},
			{u"框", u"框", u"", 0},
		}
	};

	auto* menu = f_ui_创建菜单(ctx, e_纵向, 菜单创建参数, true);

	//f_ui_添加菜单搜素项(menu, g可编译_多边形节点创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_函数_几何网格节点创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_网格参数);
	//f_ui_添加菜单搜素项(menu, g变量创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g计算创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g可编译_逻辑创建参数);
	//f_ui_添加菜单搜素项(menu, g材质创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_材质纹理创建参数);
	//f_ui_添加菜单搜素项(menu, g调试创建参数_可编译);
	return menu;
}


C_Widget* f_init并行节点创建菜单(S_UI渲染环境& ctx) {
	S_菜单创建参数 菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			//{u"物体", "物体", &g可编译_物体创建参数},
			//{u"几何", "三角网格", &g可编译_函数_几何网格节点创建参数},
			//{u"网格", "三角顶点", &g可编译_网格参数},

			//{u"变量", u"font-355", u"", &g变量创建参数_可编译},
			//{u"计算", u"mathematics5", u"", &g计算创建参数_可编译},

			//{u"逻辑", u"font-409", u"", &g着色器_逻辑菜单项},
			//{u"材质", "sphere", &g材质创建参数},
			//{u"纹理", u"图像", u"", &g可编译_材质纹理创建参数},

			//{u"笔刷", u"pack_file", u"", &g并行_笔刷},
			
			//{u"调试", "info", &g调试创建参数_可编译},
			{u"转接", u"转接", u"", 0},
			{u"框", u"框", u"", 0},
		}
	};

	auto* menu = f_ui_创建菜单(ctx, e_纵向, 菜单创建参数, true);

	//f_ui_添加菜单搜素项(menu, g可编译_多边形节点创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_函数_几何网格节点创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_网格参数);
	//f_ui_添加菜单搜素项(menu, g变量创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g计算创建参数_可编译);
	//f_ui_添加菜单搜素项(menu, g可编译_逻辑创建参数);
	//f_ui_添加菜单搜素项(menu, g材质创建参数);
	//f_ui_添加菜单搜素项(menu, g可编译_材质纹理创建参数);
	//f_ui_添加菜单搜素项(menu, g调试创建参数_可编译);
	return menu;
}


void f_节点菜单_绑定视口回调(fp_节点创建视口回调 fun) {
	
}



C_节点面板* f_节点构建_重构(C_节点面板* plane, C_节点基类* node) {
	if (!plane) {
		auto it = C_节点面板::g节点面板构建函数.find(node->m_TypeName);
		if (it != C_节点面板::g节点面板构建函数.end()) {
			plane = (it->second)(*g当前UI环境, *S_节点框架::g_3D视口环境, node, nullptr, u"");
		}
	}
	else {
		auto it = C_节点面板::g节点面板重置函数.find(node->m_TypeName);
		if (it != C_节点面板::g节点面板重置函数.end()) {
			(it->second)(plane, node);
		}
	}

	if (plane) return plane;
	else if (node->m_TypeName == "动画轨道节点") {
		if (!plane) plane = f_节点构建_非编轨道(*g当前UI环境, S_节点框架::g_3D视口环境);
		f_节点重置_非编轨道(plane, node);

	}
	

	bool 是否有创建 = false;

	是否有创建 = f_场景节点重构(&plane, node, g当前UI环境);

	if (!是否有创建) {
		是否有创建 = f_物体节点重构(&plane, node, g当前UI环境);
	}

	if (!是否有创建) {
		是否有创建 = f_计算节点重构(&plane, node, g当前UI环境);
	}

	if (!是否有创建) {
		是否有创建 = f_几何网格节点重构(&plane, node, g当前UI环境);
	}

	if (!是否有创建) {
		是否有创建 = f_物理节点重构(&plane, node, g当前UI环境);
	}

	if (!是否有创建) {
		是否有创建 = f_脚本节点重构(&plane, node, g当前UI环境);
	}


	if (!是否有创建) {
		是否有创建 = f_逻辑节点重构(&plane, node, g当前UI环境);
	}

	return plane;
}

C_节点面板* f_节点构建_从节点构建节点(C_节点基类* node, bool 是否关联, bool 创建新节点) {
	C_节点树* tree = nullptr;
	if (是否关联) {
		switch (node->m_Type) {
		case E_节点类型::e_节点Type_几何: {
			break;
		}
		case E_节点类型::e_节点Type_函数: {
			tree = ((C_函数节点*)node)->f_get子集树();
			break;
		}
		}
	}

	C_节点面板* newNode = nullptr;
	if (创建新节点) {
		newNode = C_节点面板::g节点面板构建函数[node->m_TypeName](*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, tree, u"");
	}
	else {
		newNode = C_节点面板::g节点面板构建函数[node->m_TypeName](*g当前UI环境, *S_节点框架::g_3D视口环境, node, tree, u"");
	}
	
	
	//关联节点面板
	if (tree) {
		for (auto& nodePanel : node->m_包含在多个视口的UI部件) {
			newNode->m_同子集节点树关联UI部件 = ((C_节点面板*)nodePanel)->m_同子集节点树关联UI部件;
		}
		(*newNode->m_同子集节点树关联UI部件).insert(newNode);
	}

	newNode->f_setOriginalPos(node->m_坐标);
	


	//拷贝插座
	uint32 num = node->f_get输入插座数量();
	for (uint32 i = 0; i < num; ++i) {
		auto* socket = node->f_get输入插座(i);

		if (i >= newNode->m_NodeData->f_get输入插座数量()) {
			auto* new_socket = f_su_创建节点后端插座(socket->m_identifier, socket->m_Type);
			newNode->m_NodeData->f_add插座(new_socket, E_插座方向::e_插座Type_输入, i);
			newNode->f_addInSocket(new_socket, i);
		}
		else {
			newNode->m_NodeData->f_get输入插座(i);
			f_su_切换后端插座类型(newNode->m_NodeData, E_插座方向::e_插座Type_输入, i, socket->m_Type);
		}
	}

	num = node->f_get输出插座数量();
	for (uint32 i = 0; i < num; ++i) {
		auto* socket = node->f_get输出插座(i);

		if (i >= newNode->m_NodeData->f_get输出插座数量()) {
			auto* new_socket = f_su_创建节点后端插座(socket->m_identifier, socket->m_Type);
			newNode->m_NodeData->f_add插座(new_socket, E_插座方向::e_插座Type_输出, i);
			newNode->f_addOutSocket(new_socket, i);
		}
		else {
			newNode->m_NodeData->f_get输出插座(i);
			f_su_切换后端插座类型(newNode->m_NodeData, E_插座方向::e_插座Type_输出, i, socket->m_Type);
		}
	}

	return newNode;
}

C_节点面板* f_节点构建_从节点构建节点面板(C_节点基类* plane, bool 是否关联) {
	return nullptr;
}

C_节点面板* f_节点构建_以名称构建节点(const std::string& 节点类型名称) {
	C_节点面板* plane = nullptr;
	auto it = C_节点面板::g节点面板构建函数.find(节点类型名称);
	if (it != C_节点面板::g节点面板构建函数.end()) {
		plane = (it->second)(*g当前UI环境, *S_节点框架::g_3D视口环境, nullptr, nullptr, u"");
	}
	return plane;
}


void f_NodeView_深拷贝节点(std::vector<C_节点基类*>& 节点面板, C_节点树* 节点视口) {
	


}






